XPost: comp.theory, sci.logic   
   From: F.Zwarts@HetNet.nl   
      
   Op 30.jul.2025 om 16:52 schreef olcott:   
   > 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*   
      
   This has been presented tro you many times, but you close your eyes for   
   it and pretend that it does not exist.>   
   > _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 told you that the suggestion that these 18 bytes are the whole   
   input is misleading and incorrect. The input also includes all function   
   called by DDD, directly or indirectly, including the HHH that aborts   
   after a few cycles.   
   This input specifies a halting program as other correct simulators and   
   direct execution prove.   
      
   >   
   > 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.   
      
   As usual a false claim.   
   Your huge mistake is you claim that if HHH cannot be corrected, then HHH   
   must be correct.   
   If something cannot be corrected, that does not prove that it is correct.   
   Using simulation is just the incorrect tool for this problem. A   
   simulator must fail when it tries to simulate itself, because it cannot   
   possible simulate itself correctly up to the end.   
   We know that for a larger number HHH will be able to correctly analyse   
   this input, but then we can construct another DDD, based on the new HHH,   
   for which HHH will fail again.   
   This only proves the correctness of the halting theorem. No decider   
   exists that correctly decides about the halting behaviour of all   
   possible inputs.   
      
   >   
   > https://github.com/plolcott/x86utm/blob/master/Halt7.c   
   >   
   > Failing to do that proves that you are wrong.   
      
   As usual incorrect claims without evidence.   
      
   > 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.   
      
   You may close your eyes again and pretend that the errors in your logic   
   do not eist. Very childish.   
      
   >   
   > 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.   
      
   In this case the parameter of DDD is irrelevant. HHH should take into   
   account the state changes in the simulated HHH, which influence its   
   conditional branch instructions.   
      
   >   
   >> 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;   
   > }   
   >   
      
   More relevant is:   
      
   void Finite_Recursion () {   
      int N = 5;   
      if (N > 0) Finite_Recursion ();   
      printf ("Olcott thinks this is never printed.\n");   
   }   
      
   Even if this when this function is called twice in succession without   
   any changed parameter, there is no infinite recursion.   
   The same happens inside HHH, where a count is maintained of calls to   
   DDD. This count influences the conditional branch instructions within HHH.   
      
      
   > Because they stop running as soon as their process it killed.   
      
   Irrelevant.   
      
   >   
   >> 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   
      
   Only because the simulating HHH prevents them to do so by the premature   
   abort. Without the premature abort, they do reach their final halt   
   state, as proven by other world-class simulators.   
      
   >   
   >> 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.   
      
   Indeed, the simulating HHH prevents the simulated HHH to reach its final   
   halt state.   
      
   >   
   > 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.   
      
   Counter factual. When HHH would wait 3 times, it would see that the   
   simulated HHH aborts after 2 cycles for this input with a HHH that   
   aborts after 2 cycles.   
   But you are cheating by also changing the input, so that now it requires   
   36 cycles.   
      
   >   
   >> 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*   
   >   
   I have proven it, but you close your eyes for it and claim it does not   
   exist.   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)