XPost: comp.theory, sci.math, comp.ai.philosophy   
   From: polcott333@gmail.com   
      
   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.   
   >>>   
   >>   
   >> H(P) does correctly report on the actual behavior   
   >> that its actual input actually specifies.   
   >   
   > IF it does, then you lied about building your P by the proof.   
   >   
   > As P is supposed to call H with the desciption of itself when run as an   
   > independent program.   
   >   
      
   Deciders are a pure function of their inputs   
   proving that H(P)==0 is correct and the requirement   
   is not a pure function of the input to H(P)   
      
   [continued in next message]   
      
   --- SoupGate-DOS v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)