XPost: comp.theory, sci.logic, sci.math   
   From: polcott333@gmail.com   
      
   On 11/29/2025 3:27 AM, Mikko wrote:   
   > olcott kirjoitti 28.11.2025 klo 16.46:   
   >> On 11/28/2025 2:14 AM, Mikko wrote:   
   >>> Chris M. Thomasson kirjoitti 27.11.2025 klo 9.58:   
   >>>> On 11/26/2025 11:49 PM, Mikko wrote:   
   >>>>> 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);   
      
   [continued in next message]   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)