XPost: comp.theory, comp.ai.philosophy, sci.math   
   From: mikko.levanto@iki.fi   
      
   olcott kirjoitti 26.11.2025 klo 17.17:   
   > On 11/26/2025 4:01 AM, Mikko wrote:   
   >> olcott kirjoitti 17.11.2025 klo 15.31:   
   >>> On 11/17/2025 2:43 AM, Mikko wrote:   
   >>>> On 2025-11-17 00:12:14 +0000, olcott said:   
   >>>>   
   >>>>> On 11/16/2025 3:18 AM, Mikko wrote:   
   >>>>>> On 2025-11-15 16:12:49 +0000, olcott said:   
   >>>>>>   
   >>>>>>> On 11/15/2025 4:15 AM, Mikko wrote:   
   >>>>>>>> On 2025-11-14 15:00:09 +0000, olcott said:   
   >>>>>>>>   
   >>>>>>>>> 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   
      
   [continued in next message]   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)