XPost: comp.theory, sci.logic   
   From: polcott333@gmail.com   
      
   On 7/30/2025 4:23 AM, Fred. Zwarts wrote:   
   > Op 30.jul.2025 om 05:12 schreef olcott:   
   >>   
   >> This just occurred to me:   
   >> *HHH(DDD)==0 is also correct for another different reason*   
   >>   
   >> Even if we construed the HHH that DDD calls a part of the   
   >> program under test it is true that neither the simulated   
   >> DDD nor the simulated HHH cannot possibly reach their own   
   >> final halt state.   
   > Indeed. But there are different reasons:   
   > The simulating HHH fails to reach the final halt state of the simulation   
   > because it does a premature abort,   
   *I challenge you to show a premature abort*   
      
   _DDD()   
   [00002192] 55         push ebp   
   [00002193] 8bec       mov ebp,esp   
   [00002195] 6892210000 push 00002192  // push DDD   
   [0000219a] e833f4ffff call 000015d2  // call HHH   
   [0000219f] 83c404     add esp,+04   
   [000021a2] 5d         pop ebp   
   [000021a3] c3         ret   
   Size in bytes:(0018) [000021a3]   
      
   We have been over this too many times. If it actually   
   is a premature abort then you could specify the number   
   of N instructions of DDD that must be correctly emulated   
   by HHH such that DDD reaches its own final halt state.   
      
   https://github.com/plolcott/x86utm/blob/master/Halt7.c   
      
   Failing to do that proves that you are wrong.   
   Because we have been over this so many times I am   
   convinced that you already know that you are wrong   
   and are just trolling me.   
      
   There is no stack unwinding when HHH sees DDD calls the   
   same function with the same parameter twice in sequence.   
   At this point HHH kills the whole DDD process including   
   all recursive emulations.   
      
   > based on the wrong assumption that a   
   > finite recursion specifies non-halting.   
      
   Halting is defined as reaching the "return" statement   
   final halt state. It is not defined as stopping running   
   for any reason otherwise both of these would be determined   
   to be halting:   
      
   void Infinite_Recursion()   
   {   
      Infinite_Recursion();   
      return;   
   }   
      
   void Infinite_Loop()   
   {   
      HERE: goto HERE;   
      return;   
   }   
      
   Because they stop running as soon as their process it killed.   
      
   > Then the simulating HHH does   
   > reach its own halt state when it reports non-halting.   
      
   Yet neither the simulated DDD nor the simulated HHH   
   can possibly reach their own final halt state   
      
   > The simulated HHH, that has a similar final halt state after it aborts,   
      
   The simulated HHH cannot possibly abort because the directly   
   executed HHH is always one whole recursive simulation ahead   
   thus reaching its abort criteria first.   
      
   After HHH sees that its simulated DDD is calling the same   
   function with the same parameter twice in sequence it kills   
   the whole simulated process. Even if it waited to see this   
   35 times in sequence the next inner one would have only seen   
   it 34 times, thus has not met its own abort criteria.   
      
   > does not reach it own final halt state, because the simulating HHH does   
   > not allow it to reach it by the premature abort done by the simulating HHH.   
      
   You cannot prove that your use of the term "premature abort"   
   is anything besides a misconception. *See above challenge*   
      
   --   
   Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius   
   hits a target no one else can see." Arthur Schopenhauer   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)