XPost: comp.theory, sci.math, comp.ai.philosophy   
   From: polcott333@gmail.com   
      
   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.   
      
   >>   
   >>> If you decider doesn't understand that representation, then you built   
   >>> the wrong string.   
   >>>   
   >>> It seems you are just making up craps to try to hide your error.   
   >>>   
   >>> You don't understand that you already said by claiming that P was   
   >>> built by the requirements of the proof, that you stipulated this   
   >>> string DID MEAN to your decider the algorithm / sequence of steps of   
   >>> the program to it.   
   >>>   
   >>> I guess you are just admitting you have been lying all the time, but   
   >>> were to stupid to understand that.   
   >>>   
   >>>>   
   >>>>   
   >>>>> WHy isn't the string P you gave as an input to H not a valid proxy   
   >>>>> for the input to be given to UTM?   
   >>>>>   
   >>>>> It seems like you just want to prohibit the meaning it must have to   
   >>>>> make your point, which just shows you don't know what you are   
   >>>>> talking about.   
   >>>>>   
   >>>>> If the string P you gave to H wasn't a valid proxy for the machine   
   >>>>> P, then you have just been lying about following the proof for all   
   >>>>> these years.   
   >>>>>   
   >>>>> Did you not understand that you had to be truthful to H (and thus   
   >>>>> to UTM) about the program P?   
   >>>>>   
   >>>>> Of course, that IS part of your problem, as you try to pass off an   
   >>>>> invalid string, as you want to omit the algoritm of H from it,   
   >>>>> which just shows that you never knew what you were talking about.   
   >>>>>   
   >>>>>>   
   >>>>>>> Yes, the finite string (M) *IS* a valid proxy for M, and UTM((M))   
   >>>>>>> shows what that string says, EVEN IF IT INCLUDES IT CALLING a   
   >>>>>>> copy of H.   
   >>>>>>>   
   >>>>>>> Why isn't it?   
   >>>>>>>   
   >>>>>>> How is H's DIFFERENT simulation "Correct"?   
   >>>>>>>   
   >>>>>>> Are you saying your system can't express this construction to H?   
   >>>>>>>   
   >>>>>>> If so, that just means your H fails to be able to be asked the   
   >>>>>>> question, and proves itself in error.   
   >>>>>>>   
   >>>>>>> All you are doing is admitting you can't do what you claim.   
   >>>>>>>   
   >>>>>>   
   >>>>>>   
   >>>>>   
   >>>>   
   >>>>   
   >>>   
   >>   
   >>   
   >   
      
      
   --   
   Copyright 2025 Olcott

   
      
      
   [continued in next message]   
      
   --- SoupGate-DOS v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)