XPost: comp.theory, sci.logic, sci.math   
   From: polcott333@gmail.com   
      
   On 11/14/2025 3:21 AM, Mikko wrote:   
   > On 2025-11-13 15:50:37 +0000, olcott said:   
   >   
   >> On 11/13/2025 2:48 AM, Mikko wrote:   
   >>> On 2025-11-12 12:54:12 +0000, olcott said:   
   >>>   
   >>>> On 11/12/2025 1:09 AM, Mikko wrote:   
   >>>>> On 2025-11-11 13:04:13 +0000, olcott said:   
   >>>>>   
   >>>>>> On 11/11/2025 2:59 AM, Mikko wrote:   
   >>>>>>> On 2025-11-10 14:48:00 +0000, olcott said:   
   >>>>>>>   
   >>>>>>>> On 11/10/2025 3:43 AM, Mikko wrote:   
   >>>>>>>>> On 2025-11-09 12:51:57 +0000, olcott said:   
   >>>>>>>>>   
   >>>>>>>>>> On 11/9/2025 4:22 AM, Mikko wrote:   
   >>>>>>>>>>> On 2025-11-08 13:36:06 +0000, olcott said:   
   >>>>>>>>>>>   
   >>>>>>>>>>>> On 11/8/2025 2:05 AM, Mikko wrote:   
   >>>>>>>>>>>>> On 2025-11-07 12:57:48 +0000, olcott said:   
   >>>>>>>>>>>>>   
   >>>>>>>>>>>>>> On 11/7/2025 2:05 AM, Mikko wrote:   
   >>>>>>>>>>>>>>> On 2025-11-06 20:48:02 +0000, olcott said:   
   >>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>> D simulated by H cannot possibly reach its own   
   >>>>>>>>>>>>>>>> simulated final halt state.   
   >>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>> That is merely a defect in H and irrelevanto to the   
   >>>>>>>>>>>>>>> semantic and other   
   >>>>>>>>>>>>>>> properties of D.   
   >>>>>>>>>>>>>>   
   >>>>>>>>>>>>>> That's a stupid statement.   
   >>>>>>>>>>>>>   
   >>>>>>>>>>>>> Stupid is better than false.   
   >>>>>>>>>>>>   
   >>>>>>>>>>>> It is stupidly false because you didn't bother   
   >>>>>>>>>>>> to pay any attention at all.   
   >>>>>>>>>>>   
   >>>>>>>>>>> A statement about me is off topic in comp.theory.   
   >>>>>>>>>>>   
   >>>>>>>>>>>> H simulates D that calls H(D) that   
   >>>>>>>>>>>> simulates D that calls H(D) that   
   >>>>>>>>>>>> simulates D that calls H(D) that   
   >>>>>>>>>>>> simulates D that calls H(D) that never reaches   
   >>>>>>>>>>>> the simulated "return" statement final halt   
   >>>>>>>>>>>> state of D because D calls H(D) in recursive   
   >>>>>>>>>>>> simulation.   
   >>>>>>>>>>>>   
   >>>>>>>>>>>> Have you ever done any actual programming?   
   >>>>>>>>>>>   
   >>>>>>>>>>> A question about me is off topic in comp.theory. But yes, I   
   >>>>>>>>>>> did yesterday.   
   >>>>>>>>>>   
   >>>>>>>>>> *This is my key foundational point*   
   >>>>>>>>>>   
   >>>>>>>>>> int H(char* P);   
   >>>>>>>>>>   
   >>>>>>>>>> int D()   
   >>>>>>>>>> {   
   >>>>>>>>>>    int Halt_Status = H(D);   
   >>>>>>>>>>    if (Halt_Status)   
   >>>>>>>>>>      HERE: goto HERE;   
   >>>>>>>>>>    return Halt_Status;   
   >>>>>>>>>> }   
   >>>>>>>>>>   
   >>>>>>>>>> The above is in test.c   
   >>>>>>>>>>   
   >>>>>>>>>> simulate.exe implements a C interpreter.   
   >>>>>>>>>>   
   >>>>>>>>>> simulate test.c   
   >>>>>>>>>>   
   >>>>>>>>>> runs the interpreter on the above source file   
   >>>>>>>>>> from the command prompt.   
   >>>>>>>>>   
   >>>>>>>>> Any program that does not correctly tell whether test.c halts   
   >>>>>>>>> is not   
   >>>>>>>>> a halt decider. A program that gives an incorrect answer is not   
   >>>>>>>>> even   
   >>>>>>>>> a partial halt decider.   
   >>>>>>>>>   
   >>>>>>>>>> When this interpreter sees the call to H(D)   
   >>>>>>>>>> it calls itself with the text body of D.   
   >>>>>>>>>   
   >>>>>>>>> According to C semanttics it should simulate H(D), either   
   >>>>>>>>> simultating   
   >>>>>>>>> instructions of H or simulating the return from H(D) with the same   
   >>>>>>>>> returned value as H(D) would return if executed, or do whatever   
   >>>>>>>>> H would   
   >>>>>>>>> do if H would not not return.   
   >>>>>>>>   
   >>>>>>>> That is not the behavior that the input to H(D) specifies.   
   >>>>>>>> simulator.exe simulates Test.c. This simulates D that   
   >>>>>>>> calls H(D) that the simulator recognizes as itself.   
   >>>>>>>   
   >>>>>>> It is the behavour C semantics specifies. According to C semantics   
   >>>>>>> any other behavour that produces the same result is equally valid.   
   >>>>>>>   
   >>>>>>>> So D remains stuck in recursive simulation never being   
   >>>>>>>> able to complete its first statement before calling H(D)   
   >>>>>>>> again and again.   
   >>>>>>>   
   >>>>>>> If that happens then H does not return and therefore is not a   
   >>>>>>> decider.   
   >>>>>>   
   >>>>>> Maybe my work is over your head.   
   >>>>>   
   >>>>> Maybe the definition of "decider" is over your head.   
   >>>>   
   >>>> 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);   
   >>>> }   
   >>>>   
   >>>> People here have consistently lied about   
   >>>> DD simulated by HHH reaching its own "return"   
   >>>> statement final halt state for three years.   
   >>>>   
   >>>> You yourself have not told the truth about   
   >>>> this even once.   
   >>>   
   >>> That seems to confirm that the definition of "decider" is over your   
   >>> head.   
   >>   
   >> I am just talking at the level of the execution   
   >> trace of C functions. D does specify non-halting   
   >> behavior to its termination analyzer.   
   >   
   > The termination problem is not about specifying "to its termination   
   > analyzer". Instead the termination problem is to determine whether   
   > a program terminates every time when used as it was designed to be   
   > used.   
   >   
      
   The halting problem requires that a halt decider   
   correctly report on the behavior of its caller   
   and no halt decider can even see its actual caller.   
      
   My solution is to have my H report on the behavior   
   that its actual input actually specifies.   
      
   Another solution is that because the halting problem   
   proof requires a halt decider H to report on the halt   
   status of an input D that does the opposite of   
   whatever H reports that this H/D halting problem   
   instance is merely the liar paradox in disguise.   
      
   --   
   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)