XPost: comp.theory, sci.logic   
   From: polcott333@gmail.com   
      
   On 7/30/2025 1:50 AM, Mikko wrote:   
   > On 2025-07-29 20:53:54 +0000, olcott said:   
   >   
   >> On 7/29/2025 1:37 AM, Mikko wrote:   
   >>> On 2025-07-28 12:42:24 +0000, olcott said:   
   >>>   
   >>>> On 7/28/2025 2:50 AM, Mikko wrote:   
   >>>>> On 2025-07-27 14:39:45 +0000, olcott said:   
   >>>>>   
   >>>>>> On 7/27/2025 2:36 AM, Mikko wrote:   
   >>>>>>> On 2025-07-26 16:21:19 +0000, olcott said:   
   >>>>>>>   
   >>>>>>>> On 7/26/2025 2:28 AM, Mikko wrote:   
   >>>>>>>>> On 2025-07-25 15:54:06 +0000, olcott said:   
   >>>>>>>>>   
   >>>>>>>>>> On 7/25/2025 2:43 AM, Mikko wrote:   
   >>>>>>>>>>> On 2025-07-24 21:18:32 +0000, olcott said:   
   >>>>>>>>>>>   
   >>>>>>>>>>>> On 7/24/2025 4:02 PM, joes wrote:   
   >>>>>>>>>>>>> Am Thu, 24 Jul 2025 09:11:44 -0500 schrieb olcott:   
   >>>>>>>>>>>>>> On 7/24/2025 5:07 AM, joes wrote:   
   >>>>>>>>>>>>>>> Am Wed, 23 Jul 2025 16:08:51 -0500 schrieb olcott:   
   >>>>>>>>>>>>>>>> On 7/23/2025 3:56 PM, joes wrote:   
   >>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>> Of course, and then it incorrectly assumes that an   
   >>>>>>>>>>>>>>>>> unaborted   
   >>>>>>>>>>>>>>>>> simulation *of this HHH*, which does in fact abort,   
   >>>>>>>>>>>>>>>>> wouldn't abort.   
   >>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>> If HHH(DDD) never aborts its simulation then this HHH   
   >>>>>>>>>>>>>>>> never stops   
   >>>>>>>>>>>>>>>> running.   
   >>>>>>>>>>>>>>> If HHH (which aborts) was given to a UTM/pure simulator,   
   >>>>>>>>>>>>>>> it would stop   
   >>>>>>>>>>>>>>> running.   
   >>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>> int Simulate(ptr x)   
   >>>>>>>>>>>>>> {   
   >>>>>>>>>>>>>> x(); return 1;   
   >>>>>>>>>>>>>> }   
   >>>>>>>>>>>>>>   
   >>>>>>>>>>>>>> It is the behavior of the input to HHH(DDD) that HHH is   
   >>>>>>>>>>>>>> supposed to   
   >>>>>>>>>>>>>> measure.   
   >>>>>>>>>>>>>> It is not the behavior of the input to Simulate(DDD) that   
   >>>>>>>>>>>>>> HHH is   
   >>>>>>>>>>>>>> supposed to measure.   
   >>>>>>>>>>>>>> It is also not the behavior of the directly executed DDD()   
   >>>>>>>>>>>>>> that HHH is   
   >>>>>>>>>>>>>> supposed to measure.   
   >>>>>>>>>>>>> Yes, it is. And that can obviously be computed by a   
   >>>>>>>>>>>>> processor, a UTM   
   >>>>>>>>>>>>> or any simulator that doesn't abort before the HHH called   
   >>>>>>>>>>>>> by DDD does -   
   >>>>>>>>>>>>> which HHH logically cannot do.   
   >>>>>>>>>>>>>   
   >>>>>>>>>>>>>> HHH(DDD) is only supposed to measure the behavior of its   
   >>>>>>>>>>>>>> own input.   
   >>>>>>>>>>>>> Do you understand that it trivially produces the same   
   >>>>>>>>>>>>> result as the   
   >>>>>>>>>>>>> value that it returns?   
   >>>>>>>>>>>>>   
   >>>>>>>>>>>>>> It has been three years and still not one person has   
   >>>>>>>>>>>>>> understood that the   
   >>>>>>>>>>>>>> behavior of an input that calls its own simulator is not   
   >>>>>>>>>>>>>> the same as the   
   >>>>>>>>>>>>>> behavior of an input that does not call its own simulator.   
   >>>>>>>>>>>>   
   >>>>>>>>>>>>> It is well understood that HHH does not simulate DDD the   
   >>>>>>>>>>>>> same way as the   
   >>>>>>>>>>>>> direct execution. DDD doesn't even have an "own simulator",   
   >>>>>>>>>>>>> it is just   
   >>>>>>>>>>>>> a program that you want to simulate using the simulator it   
   >>>>>>>>>>>>> happens to   
   >>>>>>>>>>>>> call.   
   >>>>>>>>>>>>   
   >>>>>>>>>>>> What has never been understood (even now) is that   
   >>>>>>>>>>>> Simulate(DDD) is presented with a different sequence   
   >>>>>>>>>>>> of x86 instructions than HHH(DDD) is presented with.   
   >>>>>>>>>>>   
   >>>>>>>>>>> That you don't understand something does not mean that it is not   
   >>>>>>>>>>> understood. Everyone other than you understand that if DDD in   
   >>>>>>>>>>> Simulate(DDD) is not the same as DDD in HHH(DDD) then one of   
   >>>>>>>>>>> them   
   >>>>>>>>>>> was given a false name (and perhaps the other, too).   
   >>>>>>>>>>   
   >>>>>>>>>> *Correctly emulated is defined as*   
   >>>>>>>>>> Emulated according to the rules of the x86 language.   
   >>>>>>>>>> This includes DDD emulated by HHH and HHH emulating   
   >>>>>>>>>> itself emulating DDD one or more times.   
   >>>>>>>>>   
   >>>>>>>>> Irrelevant. The meaning of "DDD" in a C expresssion does not   
   >>>>>>>>> depend on its   
   >>>>>>>>> immediate context.   
   >>>>>>>>   
   >>>>>>>> The meaning of a C function translated into x86   
   >>>>>>>> machine code is the meaning of this x86 machine code.   
   >>>>>>>   
   >>>>>>> Only because the C compiler attempts to preserve the meaning. The   
   >>>>>>> definitions of the meanings are distinct (except for assembly code   
   >>>>>>> insertinos that the compiler permits as a lnaguage extension).   
   >>>>>>>   
   >>>>>>> But the meaning of DDD in the C expression does not depend on its   
   >>>>>>> immediate context. The x86 codes pointed to in the two calls are   
   >>>>>>> identical or at least semantically equivalent so they specify the   
   >>>>>>> same behaviour.   
   >>>>>>>   
   >>>>>>> Independently of above considerations the meaning of DDD is the same   
   >>>>>>> in Simulate(DDD) and HHH(DDD).   
   >>>>>>   
   >>>>>> This ChatGPT analysis of its input below   
   >>>>>> correctly derives both of our views.   
   >>>>>   
   >>>>> Whatever ChatGPT says is irrelevant. If you can't defend your claims   
   >>>>> then your claims are undefencible.   
   >>>>   
   >>>> I can and have proven my claims are verified facts:   
   >>>> https://github.com/plolcott/x86utm/blob/master/Halt7.c   
   >>>> and people disagreed anyway.   
   >>>   
   >>> No, you have not. You have claimed that you have prooven but that is   
   >>> not the same. Perhaps you don't know what a proof is but it certainly   
   >>> is very different from anything you have ever presented.   
   >>   
   >> *A proof is any sequence of steps deriving a necessary result*   
   >> https://github.com/plolcott/x86utm/blob/master/Halt7.c   
   >   
   > No, it is not. There are additional requirements for each step. The   
   > sequence is a proof only if those additional requirements are satisfied.   
   >  From a practical point of view, the purpose of a proof is to convince,   
   > so what does not convince is not a proof.   
   >   
   >> Proves that HHH does correctly emulate DDD then correctly   
   >> emulates itself emulating DDD.   
   >   
   > No, it does not. The presentation is not convincing about anything   
   > and does not satisfy the requirements ot a proof.   
   >   
      
   The actual execution trace of DDD emulated by HHH   
   and DDD emulated by an emulated HHH does prove that   
   DDD has been correctly emulated by an emulated HHH.   
      
   _DDD()   
   [0000219e] 55             push ebp   
   [0000219f] 8bec           mov ebp,esp   
   [000021a1] 689e210000     push 0000219e   
   [000021a6] e843f4ffff     call 000015ee   
   [000021ab] 83c404         add esp,+04   
   [000021ae] 5d             pop ebp   
   [000021af] c3             ret   
   Size in bytes:(0018) [000021af]   
      
   _main()   
   [000021be] 55             push ebp   
   [000021bf] 8bec           mov ebp,esp   
   [000021c1] 689e210000     push 0000219e   
   [000021c6] e823f4ffff     call 000015ee   
   [000021cb] 83c404         add esp,+04   
      
   [continued in next message]   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)