XPost: comp.theory, sci.logic   
   From: richard@damon-family.org   
      
   On 7/13/24 4:36 PM, olcott wrote:   
   > *Pure function HHH is a simulating termination analyzer*   
   > DDD is correctly simulated by HHH until HHH correctly   
   > determines that it must abort its simulation of DDD   
   > to prevent its own non-termination.   
      
   Which you need to prove is possible and still gets the right answer.   
      
   >   
   > typedef void (*ptr)();   
   > int HHH(ptr P);   
   >   
   > void Infinite_Loop()   
   > {   
   >    HERE: goto HERE;   
   > }   
   >   
   > void Infinite_Recursion()   
   > {   
   >    Infinite_Recursion();   
   > }   
   >   
   > void DDD()   
   > {   
   >    HHH(DDD);   
   > }   
   >   
   > int main()   
   > {   
   >    HHH(Infinite_Loop);   
   >    HHH(Infinite_Recursion);   
   >    HHH(DDD);   
   > }   
   >   
   > Any input that must be aborted to prevent the non   
   > termination of HHH necessarily specifies non-halting   
   > behavior or it would never need to be aborted.   
   >   
      
   But if HHH does abort its simulation, as you have defined to avoid   
   getting stuck in an infinite processing, means that its input will call   
   the HHH that does the same, i.e DDD calls an HHH that WILL abort its   
   simulation and return its answer.   
      
   This means that if we give this exact input, the DDD that calls that HHH   
   that aborts its simulation and returns to an actual pure simulator that   
   continues until it reaches the final state, that simulator will simulete   
   DDD calling HHH(DDD) and that then simulating for a while and the it   
   WILL abort its simulation (since that is what your original HHH did) and   
   then return to DDD that returns.   
      
   THus, it is NOT correct that HHH needed to abort its simulation of THIS   
   input (which it happened to do), so it is incorrect in assuming that its   
   input is non-halting.   
      
   The problem is that the DEFINITION of termination analyzers is that they   
   take as input descriptions of FULL PROGRAMS, which inlcude ALL the code   
   of that program, and thus to anaylyze DDD it is also given the code for   
   the HHH that it is paired with.   
      
   When you iterate over every possible HHH, and the DDD created by pairing   
   it with that HHH, you get a DIFFERENT input for each analyzer, and thus   
   the fact that the HHH that did simulate forever didn't stop doesn't mean   
   that the simulators that do abort their simulation can look at that   
   non-aborting HHH to see the behavior of THEIR OWN input.   
      
   You need to give THIS INPUT, tied to THIS HHH to that non-aborting HHH   
   and it will simulate the full behiavor of that HHH that aborted and see   
   it return to DDD which will return and thus that HHH was incorrect in   
   its decision.   
      
   YOu are just proving that you have insufficient knowledge of the field   
   you are talking about, or even logic in general, to make a viable claim.   
      
   SORRY, you have wasted you life working on the lies you convinced   
   yourself of because you chose to make yourself ignorant of the basic   
   principles of the fields you wanted to talk about, and (incorrectly)   
   presumed you could just "guess" what those system do by casual perusal   
   of imprecise, and even incorrect articles.   
      
   > https://www.researchgate.net/publication/369971402_Simulating_   
   ermination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D   
   >   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)