XPost: comp.theory, sci.logic, sci.math   
   From: polcott333@gmail.com   
      
   On 12/26/2025 10:37 PM, Richard Damon wrote:   
   > On 12/26/25 10:48 PM, olcott wrote:   
   >> On 12/26/2025 9:37 PM, Richard Damon wrote:   
   >>> On 12/26/25 10:22 PM, olcott wrote:   
   >>>> On 12/26/2025 9:04 PM, Richard Damon wrote:   
   >>>>> On 12/26/25 9:38 PM, olcott wrote:   
   >>>>>> On 12/26/2025 7:41 PM, Richard Damon wrote:   
   >>>>>>> On 12/26/25 8:17 PM, olcott wrote:   
   >>>>>>>> On 12/26/2025 4:29 PM, Richard Damon wrote:   
   >>>>>>>>> On 12/26/25 1:07 PM, olcott wrote:   
   >>>>>>>>>> On 12/26/2025 11:26 AM, Richard Damon wrote:   
   >>>>>>>>>>> On 12/26/25 12:18 PM, olcott wrote:   
   >>>>>>>>>>>> On 12/26/2025 11:07 AM, Richard Damon wrote:   
   >>>>>>>>>>>>> On 12/26/25 11:56 AM, olcott wrote:   
   >>>>>>>>>>>>>> On 12/26/2025 10:24 AM, Richard Damon wrote:   
   >>>>>>>>>>>>>>> On 12/26/25 10:20 AM, olcott wrote:   
   >>>>>>>>>>>>>>>> On 12/26/2025 9:05 AM, Richard Damon wrote:   
   >>>>>>>>>>>>>>>>> On 12/26/25 8:54 AM, olcott wrote:   
   >>>>>>>>>>>>>>>>>> On 12/26/2025 6:59 AM, Richard Damon wrote:   
   >>>>>>>>>>>>>>>>>>> On 12/25/25 11:51 PM, olcott wrote:   
   >>>>>>>>>>>>>>>>>>>> On 12/25/2025 10:32 PM, Richard Damon wrote:   
   >>>>>>>>>>>>>>>>>>>>> On 12/25/25 10:37 PM, olcott wrote:   
   >>>>>>>>>>>>>>>>>>>>>> On 12/25/2025 9:17 PM, Richard Damon wrote:   
   >>>>>>>>>>>>>>>>>>>>>>> On 12/25/25 10:12 PM, olcott wrote:   
   >>>>>>>>>>>>>>>>>>>>>>>> Three different LLMs have been totally convinced   
   >>>>>>>>>>>>>>>>>>>>>>>> a total of 50 times, you just don't understand.   
   >>>>>>>>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>>>>>>>> LLM LIE, so are not reliable sources.   
   >>>>>>>>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>>>>>>> *Anyone that disagrees with this is not telling   
   >>>>>>>>>>>>>>>>>>>>>> the truth*   
   >>>>>>>>>>>>>>>>>>>>>> "Any result that cannot be derived as a pure function   
   >>>>>>>>>>>>>>>>>>>>>>   of finite strings is uncomputable."   
   >>>>>>>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>>>>>> But Halting *IS* a "pure function of finite strings"   
   >>>>>>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>>>>>> And it is uncomputable   
   >>>>>>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>>>>> Not exactly. Usually ⟨M⟩ simulated by H ==   
   UTM(⟨M⟩)   
   >>>>>>>>>>>>>>>>>>>> Sometimes ⟨M⟩ simulated by H != UTM(⟨M⟩)   
   >>>>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>>>> Only if H doesn't CORRECTLY simulate (M).   
   >>>>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>>> Correctly simulated is defined by the semantics   
   >>>>>>>>>>>>>>>>>> of C applied to the finite string input for   
   >>>>>>>>>>>>>>>>>> the N steps until H sees the repeating pattern.   
   >>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>> So, how does that differ from what the program actually   
   >>>>>>>>>>>>>>>>> does?   
   >>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>> Ah great this is the first time that you didn't   
   >>>>>>>>>>>>>>>> just dodge that out of hundreds of times.   
   >>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>> When-so-ever an input finite string ⟨M⟩ does not   
   >>>>>>>>>>>>>>>> cheat and call its own decider the input finite   
   >>>>>>>>>>>>>>>> string to H(⟨M⟩) is a valid proxy for UTM(⟨M⟩).   
   >>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>> So, you didn't answer the question.   
   >>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>> How does H CORRECTLY simulate the input and get a   
   >>>>>>>>>>>>>>> different result from what the program does?   
   >>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>   
   >>>>>>>>>>>>>> The finite string P  H   
   >>>>>>>>>>>>>> is not a valid proxy to UTM(P).   
   >>>>>>>>>>>>>   
   >>>>>>>>>>>>> So, you don't understand that a string is a string and you   
   >>>>>>>>>>>>> can copy it elsewhere?   
   >>>>>>>>>>>>>   
   >>>>>>>>>>>>   
   >>>>>>>>>>>> There is a key semantic difference between a finite   
   >>>>>>>>>>>> string that describes behavior and the exact sequence   
   >>>>>>>>>>>> of steps that a finite string input specifies to a   
   >>>>>>>>>>>> specific instance of a decider.   
   >>>>>>>>>>>   
   >>>>>>>>>>> Really?   
   >>>>>>>>>>>   
   >>>>>>>>>>> And why is that?   
   >>>>>>>>>>>   
   >>>>>>>>>>> Since the DEFINITION of semantics for strings representing   
   >>>>>>>>>>> programs is the operation of that program.   
   >>>>>>>>>>>   
   >>>>>>>>>>> Note, the string represents what it represents to EVERYTHING.   
   >>>>>>>>>>>   
   >>>>>>>>>>   
   >>>>>>>>>> That definition has always been less than 100%   
   >>>>>>>>>> precisely accurate even when one takes the vague   
   >>>>>>>>>> term: "represents" with a more precise term of   
   >>>>>>>>>> the art-meaning.   
   >>>>>>>>>   
   >>>>>>>>> Nope, nothing can be more accurate than the actual definition,   
   >>>>>>>>>   
   >>>>>>>>> You got a source for your claim, or is this just another lie   
   >>>>>>>>> out of your insanity.   
   >>>>>>>>>   
   >>>>>>>>>>   
   >>>>>>>>>> I simply bypass all of that by defining the new   
   >>>>>>>>>> idea of the sequence of steps that a finite string   
   >>>>>>>>>> input instance specifies to its decider instance.   
   >>>>>>>>>   
   >>>>>>>>> But you don't GET to define the new idea, not without admitting   
   >>>>>>>>> you are leaving Computation Theory.   
   >>>>>>>>>   
   >>>>>>>>> All you are doing is admitting that you logic is built on lying,   
   >>>>>>>>>   
   >>>>>>>>>>   
   >>>>>>>>>> That is a level of precision that no one bothered   
   >>>>>>>>>> to think about for 90 years. That this level of   
   >>>>>>>>>> detail is empirically proven to make an actual   
   >>>>>>>>>> difference conclusively validates it.   
   >>>>>>>>>   
   >>>>>>>>> No, your level of stupidity, thinking you get to redefine   
   >>>>>>>>> thing, is show to be great.   
   >>>>>>>>>   
   >>>>>>>>> As I said, All you have done is proved that you don't know what   
   >>>>>>>>> you are talking about, but are just making up lies.   
   >>>>>>>>>   
   >>>>>>>>> If you can't prove your claim in the system, from the defined   
   >>>>>>>>> definition, your claims are just admitted lies.   
   >>>>>>>>>   
   >>>>>>>>   
   >>>>>>>> Turing machine deciders: Transform finite string   
   >>>>>>>> inputs by finite string transformation rules into   
   >>>>>>>> {Accept, Reject} values.   
   >>>>>>>>   
   >>>>>>>> All that I am doing is exploring the exact details   
   >>>>>>>> of that. That no one else bothered to explore these   
   >>>>>>>> exact details is no mistake of mine.   
   >>>>>>>>   
   >>>>>>> So, your H / HH / HHH can be halt decider, at least if you define   
   >>>>>>> them in a way that meets the requirements, which your code   
   >>>>>>> doesn't, since their transform depends on hidden state.   
   >>>>>>>   
   >>>>>>   
   >>>>>> Implementation details are irrelevant to theoretical limits.   
   >>>>>   
   >>>>> Not if they mean they don't meet the requirements.   
   >>>>>   
   >>>>>> H does apply finite string transformation rules to its   
   >>>>>> input P deriving {Reject}.   
   >>>>>   
   >>>>> Which makes it a decider, not a halting decider.   
   >>>>>   
   >>>>   
      
   [continued in next message]   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)