XPost: comp.theory, sci.logic   
   From: F.Zwarts@HetNet.nl   
      
   Op 31.jul.2025 om 09:28 schreef olcott:   
   > On 7/31/2025 2:20 AM, Fred. Zwarts wrote:   
   >> Op 30.jul.2025 om 16:12 schreef olcott:   
   >>> On 7/30/2025 4:09 AM, Fred. Zwarts wrote:   
   >>>   
   >>> Simulating N instructions correctly does mean that   
   >>> these N instructions were simulated correctly.   
   >>   
   >> Nobody denies that, but it does not make te whole simulation correct.   
   >  >>   
   >>>> In contrast, the failure to simulate a single instruction correctly,   
   >>>> makes the whole simulation incorrect.   
   >>>> In this case it is the failure to simulate the call instruction.   
   >>>   
   >>> My code conclusively proves that HHH does simulate   
   >>> itself simulating DDD. That you do not understand   
   >>> this code well enough to understand that is less   
   >>> than no rebuttal at all.   
   >>   
   >> Incorrect claims, as usual.   
   >> I do understand it and in fact better that you do. You do not   
   >> understand that the simulation is not correct when the simulation is   
   >> not completed.   
   >> You also do not understand that a finite recursion does not imply non-   
   >> halting.   
   >>   
   >>>   
   >>>> The simulation aborts at this point, where the semantics of the x86   
   >>>> language requires the execution of the next instruction.   
   >>>   
   >>> 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,   
   >>   
   >> Incorrect. It aborts when it sees a finite recursion.   
   > It sees recursive simulation that can never reach the halt state.   
      
      
   Incorrect wording. It sees a finite recursion, but it is unable to   
   determine that it is a finite recursion because of a programming error.   
   The reason is:   
      
   >   
   >> The programmer forgot to count the conditional branch instruction, so   
   >> that it incorrectly reports non-halting.   
   >>   
   >>> (b) Its simulated input reaches its simulated "return" statement then   
   >>> it returns 1.   
   >>>   
   >>> My code conclusively proves that HHH does simulate itself   
   >>> simulating DDD until any sufficiently competent person can   
   >>> correctly determine a repeating pattern that cannot possibly   
   >>> reach its own "return" statement final halt state even with   
   >>> an infinite simulation.   
   >>   
   >> Incorrect repeated claim, as usual. Any competent person knows that a   
   >> finite recursion, or a finite repeating pattern, does not mean non-   
   >> termination.   
   >> Better simulators also show that after the finite recursion, the final   
   >> halt state is reachable.   
   >> That HHH is unable to reach the final halt state, therefore, is a   
   >> failure of HHH.   
   >>   
   >>>   
   >>> That you do not understand this code well enough to   
   >>> understand that is less than no rebuttal at all.   
   >>   
   >> As usual, incorrect repeated claim, without any evidence.   
   >>   
   >>> https://github.com/plolcott/x86utm/blob/master/Halt7.c   
   >>   
   >> The HHH that is called by DDD in the simulation, is the HHH that   
   >> aborts and returns. So, the input for the simulation specifies a   
   >> halting program.   
   >> That HHH fails to see the whole specification, does not change the   
   >> specification.   
   >> Your huge mistake is that you think that what HHH does not see, does   
   >> not exist.   
   >>   
   >>>   
   >>> When it does detect this pattern then it kills the   
   >>> whole DDD process so that there is no stack unwinding.   
   >>   
   >> But there was no need to do so. Other simulators show that when the   
   >> simulation is not killed, the final halt state is reached.   
   >>   
   >>>   > This premature abort, based on the incorrect assumption that a   
   >>> finite   
   >>>> recursion specifies non-halting, makes the whole simulation   
   >>>> incorrect and, what is worse, the conclusion of non-halting   
   >>>> behaviour fails.   
   >>>>   
   >>>   
   >>> HHH uses exactly same process on this function.   
   >>>   
   >>> void Infinite_Recursion()   
   >>> {   
   >>>    Infinite_Recursion();   
   >>>    return;   
   >>> }   
   >>>   
   >>> as it does this function.   
   >>   
   >> Incorrect, it more like:   
   >>   
   >> void Finite_Recursion (int N) {   
   >>    if (N > 0) Finite_Recursion (N - 1);   
   >>    printf ("Olcott thinks this is never printed.\n");   
   >> }   
   >>   
   >> Because we know that HHH, also the simulated HHH, is programmed to   
   >> abort after a few cycles.   
   >>   
   >>>   
   >>> void DDD()   
   >>> {   
   >>>    HHH(DDD);   
   >>>    return;   
   >>> }   
   >>>   
   >>> HHH has no idea that DDD is calling itself.   
   >>   
   >> Programs have no ideas. They do what is coded.   
   >> When you still want to think about ideas: DDD has no idea that HHH   
   >> will simulate itself recursively. It expects HHH to return.   
   >>   
   >>> HHH just sees that DDD is calling the same function   
   >>> with the same parameter twice in sequence,   
   >>   
   >> but a good simulator would see that the internal state of HHH has been   
   >> changed, which would influence the conditional branch instructions.   
   >>   
   >>> just like   
   >>   
   >> Finite_Recursion, not like:   
   >>   
   >>> Infinite_Recursion().   
   >>>   
   >>>> Further irrelevant claims without evidence ignored.   
   >>>>   
   >>>>>   
   >>>>> Perhaps you have an ACM email address and don't   
   >>>>> know very much about programming?   
   >>>   
   >>>   
   >>   
   >   
   >   
      
      
   --   
   Paradoxes in the relation between Creator and creature.   
   .   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)