XPost: comp.theory, comp.ai.philosophy, sci.math   
   From: mikko.levanto@iki.fi   
      
   olcott kirjoitti 3.12.2025 klo 18.27:   
   > On 12/3/2025 5:34 AM, Mikko wrote:   
   >> olcott kirjoitti 2.12.2025 klo 16.14:   
   >>> On 12/2/2025 3:07 AM, Mikko wrote:   
   >>>> olcott kirjoitti 1.12.2025 klo 14.47:   
   >>>>> On 12/1/2025 4:45 AM, Mikko wrote:   
   >>>>>> olcott kirjoitti 29.11.2025 klo 18.38:   
   >>>>>>> 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.   
      
   [continued in next message]   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)