XPost: comp.theory, sci.logic, sci.math   
   From: polcott333@gmail.com   
      
   On 12/19/2025 8:57 PM, Richard Damon wrote:   
   > On 12/19/25 6:46 PM, olcott wrote:   
   >> On 12/19/2025 5:20 PM, Richard Damon wrote:   
   >>> On 12/19/25 6:13 PM, olcott wrote:   
   >>>> On 12/19/2025 4:01 PM, Richard Damon wrote:   
   >>>>> On 12/19/25 11:13 AM, olcott wrote:   
   >>>>>   
   >>>>>> Computations: Transform finite strings by finite   
   >>>>>> string transformation rules into values or nontermination.   
   >>>>>>   
   >>>>>> Deciders: Transform finite strings by finite string   
   >>>>>> transformation rules into {Accept, Reject}.   
   >>>>>   
   >>>>> But XXX Deciders need to transform there finite string to {Accept,   
   >>>>> Reject} in a manner that MATCHES the XXX function.   
   >>>>>   
   >>>>   
   >>>> Not when there is no transformation from the input   
   >>>> to the required value.   
   >>>   
   >>> In other words, you think UTM don't exist.   
   >>>   
   >>   
   >> This boils my whole point down much more succinctly than   
   >> ever before and it is derived from standard definitions.   
   >>   
   >> Computations: Transform finite strings by finite   
   >> string transformation rules into values or non-termination.   
   >>   
   >> Deciders: Transform finite strings by finite string   
   >> transformation rules into {Accept, Reject}.   
   >>   
   >> When UTM(P) and H.UTM(P) vary then it is H.UTM(P)   
   >> that rules because H is only required to report on   
   >> the behavior that it actual input actually specifies.   
   >>   
   >   
   >   
   > Nope, because you H.UTM isn't a UTM, and thus you can't use it. You   
   > BROKE the code with your modifications.   
   >   
      
   If H is only a UTM then H(P) never halts.   
      
   If H is a UTM that simply stops after one million   
   steps then H reaches its final halt state and P   
   never reaches is final halt state.   
      
   > There *IS* a transformation from the string of the input to the   
   > behavior, and that is of a real UTM, and that DOES match the behavior of   
   > the direct execution of the machine it describes.   
   >   
      
   Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy // accept state   
   Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn // reject state   
      
   H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy // accept state   
   H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // reject state   
      
   The behavior of Ĥ applied to ⟨Ĥ⟩ and H applied to ⟨Ĥ⟩   
   is not the same.   
      
   > You just don't understand basics, like the meaning of the words you use,   
   > and that rules matter.   
   >   
   > To try to change them is to just make yourself a liar.   
      
      
   --   
   Copyright 2025 Olcott

   
      
   My 28 year goal has been to make 
   
   "true on the basis of meaning expressed in language"
   
   reliably computable.

   
      
   This required establishing a new foundation
   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)