XPost: comp.theory, comp.lang.c++, sci.math   
   From: polcott333@gmail.com   
      
   On 10/13/2025 3:07 AM, joes wrote:   
   > Am Sat, 11 Oct 2025 23:28:06 -0500 schrieb olcott:   
   >> On 10/11/2025 11:08 PM, dbush wrote:   
   >>> On 10/11/2025 11:51 PM, olcott wrote:   
   >>>> On 10/11/2025 10:42 PM, dbush wrote:   
   >>>>> On 10/11/2025 11:34 PM, olcott wrote:   
   >>>>>> On 10/11/2025 10:23 PM, dbush wrote:   
   >   
   >>>>>>> We know that a non-halting behavior pattern *does not* exist in   
   >>>>>>> algorithm DD because it halts when executed directly.   
   >>>>>>   
   >>>>>> Yet that answer is not according to the actual behavior that *THE   
   >>>>>> INPUT ITSELF* to HHH(DD)   
   >   
   > The input, as imagined by you to be distinct from the program, does not   
   > have any behaviour of its own. You are referring entirely to HHH’s   
   > simulation of it, which depends on how it chooses to simulate it.   
   >   
      
   The input to a UTM specifies behavior to this UTM.   
      
   >>>>>> it is the behavior of a non-input that is misconstrued as an input.   
   >>>>> No, you're the one claiming that HHH(DD) must report on the non-input   
   >>>>> DDn   
   >>>> HHH(DD) is reporting on the otherwise unlimited recursive simulation   
   >>>> that its actual finite string of x86 machine code specifies.   
      
   > The code of DD „specifies” finite recursion. What are you talking about.   
   >   
      
      
   Please think this all the way through without making any guesses.   
      
   Simulating Termination Analyzer HHH correctly simulates its input until:   
   (a) Detects a non-terminating behavior pattern:   
        abort simulation and return 0.   
   (b) Simulated input reaches its simulated "return" statement:   
        return 1.   
   (c) If HHH must abort its simulation to prevent its own non-termination   
        then HHH is correct to abort this simulation and return 0.   
      
   typedef int (*ptr)();   
   int HHH(ptr P);   
      
   int DD()   
   {   
      int Halt_Status = HHH(DD);   
      if (Halt_Status)   
        HERE: goto HERE;   
      return Halt_Status;   
   }   
      
   int main()   
   {   
      HHH(DD);   
   }   
      
   What value should HHH(DD) correctly return?   
      
      
   LLM systems can be trusted to perform correct   
   semantic logical entailment from a set premises   
   without the possibility of AI hallucination.   
      
   They are 67-fold better at this than they were one   
   year ago because their context window increased from   
   3000 words to 200,000 words in the last year. That   
   means they can keep far more reasoning "in their head".   
      
   ChatGPT 5.0 agrees with me on this now:   
   The input to HHH(DD) specifies recursive simulation   
   that must be aborted to prevent its own non-termination.   
      
   The directly executed DD() is not a finite string   
   thus is outside of the domain of HHH thus does not   
   contradict that HHH(DD) rejects its input.   
      
   When the halting problem asks the question does   
   the machine specified by this machine description   
   halt?   
      
   within this concrete model it is asking a question   
   that it outside of the domain of any decider.   
      
   >>> In other words, you imagine changing the code of function HHH to not   
   >>> abort, resulting in you now having algorithms HHHn and DDn and   
   >>> reporting on the behavior of the non-input algorithm DDn.   
   >> Not at all, its a freaking "if" statement.   
   > Exactly, if the input DD were actually DDn.   
   >   
   >>>>> But since Turing machines always have exactly the same behavior for a   
   >>>>> given input,   
   >>>> I don't think that is literally true.   
   >>> Yes.  It is true by the meaning of the words.  If not, you could   
   >>> provide a Turing machine X such that X(Y) behaves differently at   
   >>> different times.   
   >> UTM1(D) specifies a different sequence of moves than UTM2(D) because D   
   >> has UTM1 embedded within it and does not have UTM2 embedded within it.   
   > WDYM with a simulator specifies? All UTMs are equal. HHH is not a UTM.   
   > HHH certainly diverges from the trace produced by direct execution.   
   >   
   >>>> Computable functions   
   >>> i.e. mathematical mappings for which an algorithm exists to compute   
   >>> them   
   >>>> are required to have exactly the same behavior for the same input.   
   >>> Mathematical mappings don't have behavior.  They simply associate   
   >>> inputs to outputs.   
   >> Yes. The algorithm computes the mapping from its finite string input   
   > HHH does not compute the mapping from DD to its halt status.   
   >   
   >>>> HHH does have exactly the same behavior for the same input. DD is not   
   >>>> a computable function.   
   >>> Category error: C functions aren't mathematical mappings.   
   >> C functions that are a pure function of their inputs do compute mappings   
   >> from their inputs.   
   > HHH is not pure. DD is computable, as evidenced by running it.   
   >   
   >>>   Algorithm DD *computes* some computable function.   
   >> pretty good trick to make it a pure function of the empty string.   
   >>> And the input to algorithm DD is   
   >> the empty string.   
   >>> an execution trace   
   >> nope it is the empty string.   
   >   
   > DD relies on global data.   
   >   
   >>> which it also gives to HHH as an input, so HHH is therefore   
   >>> DISQUALIFIED from being a halting decider.   
   >   
   >>>>> we can ask about the hypothetical case when machine DD is executed   
   >>>>> directly, not necessarily "now", by giving it the finite string   
   >>>>> description of machine DD which is specified to possess all semantic   
   >>>>> properties of machine DD including the fact that it halts when   
   >>>>> executed directly.   
   >>>> That is not the actual behavior of the actual input   
   > Is the „actual behaviour” whatever the simulator simulates?   
   >   
   >>> i.e. finite string DD, which is a description of machine DD and is   
   >>> specified to possess all semantic properties of machine DD, including   
   >>> the fact that it halts when executed directly.   
   >> It also specifies that it calls HHH(DD).   
   > Which aborts after a finite number of recursive simulations, not   
   > running forever.   
   >   
   >>>> as measured by the simulation of DD by HHH according to the semantics   
   >>>> of its language,   
   >>> But HHH aborts in violation of the x86 language, therefore you have no   
   >>> measure.   
   >> Nope knuckle head you are incorrect.   
   > x86 does not allow arbitrarily stopping execution.   
   >   
   >>> False.  It is a semantic tautology that the ultimate measure of correct   
   >>> simulation is that it exactly matches the behavior of the machine it is   
   >>> simulating.   
   >> Not when the violates the semantics of its language.   
   > Such as not continuing to simulate. Or what is the violation?   
   >   
      
      
   --   
   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)