XPost: comp.theory, comp.lang.c++, comp.lang.c   
   From: polcott333@gmail.com   
      
      
        If simulating halt decider H correctly simulates its   
        input D until H correctly determines that its simulated D   
        would never stop running unless aborted then   
      
        H can abort its simulation of D and correctly report that D   
        specifies a non-halting sequence of configurations.   
      
      
   On 10/14/2022 7:44 PM, Ben Bacarisse wrote:   
    > I don't think that is the shell game. PO really /has/ an H   
    > (it's trivial to do for this one case) that correctly determines   
    > that P(P) *would* never stop running *unless* aborted.   
      
   This was verified on the basis of the x86utm operating   
   system that provided an execution trace in the x86   
   language that was too difficult for anyone to understand.   
   https://github.com/plolcott/x86utm   
   This took about one year of full time development effort.   
      
   *Updated words*   
      Simulating termination analyzer H simulates   
      N statements of D according to the semantics of   
      the C programming language. H does this until it   
      matches a correct non-halting behavior pattern.   
      This pattern conclusively proves that the simulated   
      D cannot possibly reach its own simulated "return"   
      statement final halt state for any value of N.   
      
      Then H aborts its simulation and returns 0 on the   
      basis that that its input D specifies a non-halting   
      sequence of instructions.   
      
   This is empirically proven by a C interpreter.   
   (Detailed design provided below)   
      
   int H(char* P);   
      
   int D()   
   {   
      int Halt_Status = H(D);   
      if (Halt_Status)   
        HERE: goto HERE;   
      return Halt_Status;   
   }   
      
   The above is assumed in in test.c   
      
   simulate.exe implements a C interpreter.   
      
   Command line invocation: simulate test.c   
      
   When this interpreter sees the call to H(D) it   
   calls itself with the text body of D. I intend   
   to make this generic for any named function.   
      
   The above proves that N instructions of D simulated   
   by H according to the semantics of the C programming   
   language cannot possibly reach its own "return"   
   statement final halt state.   
      
   It is estimated that the adaptation of an existing   
   C interpreter should take about one full time week.   
   I already found one that can call itself recursively.   
      
   The tricky part that might require YACC and LEX is   
   parsing the input file to recognize instances of H   
   that must be called with text strings of function bodies.   
      
   --   
   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)