XPost: comp.theory, sci.math, comp.ai.philosophy   
   From: polcott333@gmail.com   
      
   On 12/20/2025 5:36 PM, Richard Damon wrote:   
   > On 12/20/25 6:26 PM, olcott wrote:   
   >> On 12/20/2025 5:08 PM, Richard Damon wrote:   
   >>> On 12/20/25 5:55 PM, olcott wrote:   
   >>>> On 12/20/2025 4:37 PM, Richard Damon wrote:   
   >>>>> On 12/20/25 5:05 PM, olcott wrote:   
   >>>>>> On 12/20/2025 4:02 PM, Richard Damon wrote:   
   >>>>>>> On 12/20/25 4:36 PM, olcott wrote:   
   >>>>>>>> On 12/20/2025 3:17 PM, Richard Damon wrote:   
   >>>>>>>>> On 12/20/25 3:56 PM, olcott wrote:   
   >>>>>>>>>> On 12/20/2025 2:41 PM, Richard Damon wrote:   
   >>>>>>>>>>> On 12/20/25 3:19 PM, olcott wrote:   
   >>>>>>>>>>>> On 12/20/2025 1:51 PM, Richard Damon wrote:   
   >>>>>>>>>>>>> On 12/20/25 2:22 PM, olcott wrote:   
   >>>>>>>>>>>>>> On 12/20/2025 12:56 PM, Richard Damon wrote:   
   >>>>>>>>>>>>>>> On 12/20/25 9:54 AM, olcott wrote:   
   >>>>>>>>>>>>>>>> On 12/20/2025 8:41 AM, Richard Damon wrote:   
   >>>>>>>>>>>>>>>>> On 12/20/25 8:49 AM, olcott wrote:   
   >>>>>>>>>>>>>>>>>> On 12/20/2025 4:07 AM, Mikko wrote:   
   >>>>>>>>>>>>>>>>>>> On 20/12/2025 03:27, olcott wrote:   
   >>>>>>>>>>>>>>>>>>>> Deciders: Transform finite strings by finite   
   >>>>>>>>>>>>>>>>>>>> string transformation rules into {Accept, Reject}   
   >>>>>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>>>>> https://philpapers.org/archive/OLCDTF.pdf   
   >>>>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>>>> As there are no halt deciders they don't work at all.   
   >>>>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>>> The above defines the generic notion of decider.   
   >>>>>>>>>>>>>>>>>> There are deciders.   
   >>>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>> But not Halt Deciders.   
   >>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>> When a halt decider is defined to exceed what   
   >>>>>>>>>>>>>>>> generic deciders can do then this definition   
   >>>>>>>>>>>>>>>> is incorrect.   
   >>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>> But it isn't. A Halt Decider needs to compute a result   
   >>>>>>>>>>>>>>> from the finite string.   
   >>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>   
   >>>>>>>>>>>>>> Exactly.   
   >>>>>>>>>>>>>>   
   >>>>>>>>>>>>>> Deciders: Transform finite strings by finite string   
   >>>>>>>>>>>>>> transformation rules into {Accept, Reject}.   
   >>>>>>>>>>>>>   
   >>>>>>>>>>>>> So, you are just admitting you are stupid, as you can't   
   >>>>>>>>>>>>> keep the terms straight because you mind is to crooked.   
   >>>>>>>>>>>>>   
   >>>>>>>>>>>>> The behavior of the finite string that represents this   
   >>>>>>>>>>>>> Program P, built on your defined program H is computable,   
   >>>>>>>>>>>>> as shown by the fact that UTM(P) produces the required   
   >>>>>>>>>>>>> result of the behavior of running this program P.   
   >>>>>>>>>>>>>   
   >>>>>>>>>>>>   
   >>>>>>>>>>>> I was not as clear as possible:   
   >>>>>>>>>>>> Deciders: Transform finite string inputs by finite   
   >>>>>>>>>>>> string transformation rules into {Accept, Reject}.   
   >>>>>>>>>>>>   
   >>>>>>>>>>>> There are no finite string transformation rules   
   >>>>>>>>>>>> that H can apply to its input P that derive the   
   >>>>>>>>>>>> behavior of UTM(P).   
   >>>>>>>>>>>>   
   >>>>>>>>>>>   
   >>>>>>>>>>> That isn't a valid statement,   
   >>>>>>>>>>   
   >>>>>>>>>> Prove that it isn't a valid statement by showing   
   >>>>>>>>>> the finite string transformations that HHH can   
   >>>>>>>>>> apply to DD to derive the same behavior as DD   
   >>>>>>>>>> simulated by HHH1.   
   >>>>>>>>>>   
   >>>>>>>>>   
   >>>>>>>>> Since HHH only does one specific finite string transformation,   
   >>>>>>>>> that can't be the definition of what determines the answer.   
   >>>>>>>>>   
   >>>>>>>>   
   >>>>>>>> Try and figure out how HHH can apply better finite string   
   >>>>>>>> transformation rules to *ITS ACTUAL INPUT* than DD simulated   
   >>>>>>>> by HHH. DO this so that it derives the same behavior as   
   >>>>>>>> DD simulated by HHH1.   
   >>>>>>>>   
   >>>>>>>   
   >>>>>>> Why does it need to?   
   >>>>>>>   
   >>>>>>   
   >>>>>> Deciders: Transform finite string inputs by finite   
   >>>>>> string transformation rules into {Accept, Reject}.   
   >>>>>>   
   >>>>>> They are not accountable for anything else.   
   >>>>>> Both HHH(DD) and HHH1(DD) do this correctly.   
   >>>>>>   
   >>>>>>   
   >>>>>>   
   >>>>>   
   >>>>> Sure they are. They just need to use their finite string   
   >>>>> transformation to get to the required answer.   
   >>>>>   
   >>>>> After all, an XXX Decider needs to compute the XXX function of   
   >>>>> their input.   
   >>>>>   
   >>>>   
   >>>> Only to the extent that there exists some finite   
   >>>> string transformation rules from its input that   
   >>>> derive the required result otherwise it turns out   
   >>>> that the requirements themselves are incorrect.   
   >>>   
   >>> Nope, to be an XXX Decider, you need to compute the XXX function.   
   >>>   
   >>   
   >> *Counter-factual on this basis*   
   >> (It did take me 22 years to derive that basis)   
   >>   
   >> Deciders: Transform finite string inputs by finite   
   >> string transformation rules into {Accept, Reject}.   
   >> They are not accountable for anything else.   
   >>   
   >>   
   >   
   > WRONG, and prove your stupidity.   
   >   
   > Remember you definition of a "Computable Function"?   
   >   
   > If the Turing Machine doesn't compute the specified function, it failed   
   > to do its duty.   
   >   
      
   Prior to my elaboration this was hidden in   
   a slightly incorrect basic frame-of-reference.   
      
   Yet with my elaboration it becomes clear that   
   when the function is not computable from the input   
   then it is the requirement that is wrong.   
      
   We when require sum(3,4) to produce the sum of 5 + 6   
   it is the requirement that is wrong.   
      
   With the halting problem the issue it is so   
   enormously more subtle that it took one guys   
   focus for 22 years.   
      
   It turns out that if undecidability is correct   
   then truth itself is broken. If I didn't know   
   that I would have given up after six months.   
      
   > All deciders with a specified function to compute are responsible to   
   > match that function.   
   >   
   > Deciders without a specified function are basically worthless, as there   
   > answers are meaningless. The only question they answer is what does this   
   > program generate for this input.   
      
      
   --   
   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)