XPost: comp.theory, sci.logic   
   From: F.Zwarts@HetNet.nl   
      
   Op 29.jul.2025 om 23:15 schreef olcott:   
   > On 7/29/2025 2:39 AM, Fred. Zwarts wrote:   
   >> Op 28.jul.2025 om 14:46 schreef olcott:   
   >>> On 7/28/2025 3:43 AM, Fred. Zwarts wrote:   
   >>>> Op 26.jul.2025 om 20:46 schreef olcott:   
   >>>>> On 7/26/2025 1:11 PM, joes wrote:   
   >>>>>> Am Sat, 26 Jul 2025 08:48:48 -0500 schrieb olcott:   
   >>>>>>> On 7/26/2025 3:05 AM, joes wrote:   
   >>>>>>>> Am Fri, 25 Jul 2025 15:02:16 -0500 schrieb olcott:   
   >>>>>>>>> On 7/25/2025 2:10 PM, joes wrote:   
   >>>>>>>>>> Am Fri, 25 Jul 2025 11:32:03 -0500 schrieb olcott:   
   >>>>>>   
   >>>>>>>>>> Oh, really now? I thought it referred to its simulator HHH by   
   >>>>>>>>>> name.   
   >>>>>>>>> The actual code has always been based on an x86 emulator that   
   >>>>>>>>> emulates   
   >>>>>>>>> finite strings of x86 machine code bytes.   
   >>>>>>>> But does DDD call whatever is behind the name "HHH" or does it   
   >>>>>>>> call the   
   >>>>>>>> fixed code that aborts just before the second recursive call?   
   >>>>>>>> Because   
   >>>>>>>> DDD calling a modified HHH' is a different program.   
   >>>>>>> When HHH emulates DDD then DDD calls HHH(DDD) based on whatever   
   >>>>>>> code is   
   >>>>>>> at machine address 000015d2.   
   >>>>>> Ok, so modifying HHH to simulate further also changes the input DDD,   
   >>>>>> because it calls the same address. Gotcha.   
   >>>>>>   
   >>>>>>>>> For three years everyone here acts like it is impossible for   
   >>>>>>>>> them to   
   >>>>>>>>> understand that the correct emulation of an input that calls   
   >>>>>>>>> its own   
   >>>>>>>>> emulator HHH(DDD) can possibly be different than the emulation   
   >>>>>>>>> of the   
   >>>>>>>>> same input that does not call its own emulator HHH1(DDD).   
   >>>>>>>> It is not impossible to understand. It is wrong.   
   >>>>>>> Since the execution trace conclusively proves that it is correct   
   >>>>>>> your   
   >>>>>>> mere intuition to the contrary is proven to be incorrect.   
   >>>>>> The trace only shows it is different. It remains to be shown that the   
   >>>>>> abort was correct.   
   >>>>>>   
   >>>>>>>> If we prefix all programs we pass to HHH with DDD, they should   
   >>>>>>>> not be   
   >>>>>>>> aborted as if the were the same.   
   >>>>>>>> If HHH were a correct simulator, it would produce the same   
   >>>>>>>> behaviour as   
   >>>>>>>> an UTM. (HHH1 is the same as HHH, right?)   
   >>>>>> Right?   
   >>>>>>   
   >>>>>   
   >>>>> All of the chatbots figure out that I am correct   
   >>>>> on their own. I only give them this input:   
   >>>>>   
   >>>>> typedef void (*ptr)();   
   >>>>> int HHH(ptr P);   
   >>>>>   
   >>>>> void DDD()   
   >>>>> {   
   >>>>>    HHH(DDD);   
   >>>>>    return;   
   >>>>> }   
   >>>>>   
   >>>>>   
   >>>>> int main()   
   >>>>> {   
   >>>>>    HHH(DDD);   
   >>>>>    DDD();   
   >>>>> }   
   >>>>>   
   >>>>> Simulating Termination Analyzer HHH correctly simulates its input   
   >>>>> until:   
   >>>>> (a) It detects a non-terminating behavior pattern then it aborts   
   >>>>> its simulation and returns 0,   
   >>>>> (b) Its simulated input reaches its simulated "return" statement   
   >>>>> then it returns 1.   
   >>>>   
   >>>> These cache-boxes are fed with invalid and contradictory information:   
   >>>> (a) No non-termination pattern can be detected when it aborts and   
   >>>> return, because the simulated HHH is also programmed to abort and   
   >>>> return.   
   >>>   
   >>> DDD correctly simulated by HHH cannot possibly reach its own   
   >>> simulated "return" instruction final halt state in one to   
   >>> infinity steps of correct simulation. This is a verified fact.   
   >>>   
   >>>   
   >> As usual incorrect claims without evidence.   
   >> Your dreams are no verified facts. HHH aborts before the simulation   
   >> would reach the final halt state in a finite number of steps, as   
   >> proven by world-class simulators using exactly the same input. The   
   >> infinity is only in your dreams.   
   >>   
   >   
   > HHH(DDD) must simulate itself simulating DDD because DDD calls HHH(DDD)   
      
   Indeed and this 'itself' is HHH, not HHH1.   
      
   >   
   > HHH1(DDD) must NOT simulate itself simulating DDD because DDD DOES NOT   
   > CALL HHH1(DDD)   
      
   No, HHH1 must simulate the same as HHH, namely HHH. Because that is what   
   the input specifies.   
      
   So, both must simulate the same thing: HHH. Here HHH fails, because it   
   cannot simulate itself up to the end, but HHH1 succeeds, because it has   
   no problem to simulate HHH.   
      
   When both are simulating exactly the same thing, namely HHH, where one   
   does not reach the final halt state and the other one succeeds to reach   
   it, it is a proof that Hush’s simulation is incorrect.   
      
   Further irrelevant and incorrect claims ignored. They only prove the   
   lack of arguments or honesty.   
      
   >   
   > At this point I think that you are a fucking liar.   
   >   
   >   
   >   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)