XPost: comp.theory, sci.math, comp.ai.philosophy   
   From: polcott333@gmail.com   
      
   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.   
      
   There are no correct finite string transformation   
   rules that HHH can possibly apply to its actual   
   input that derive the behavior of DD simulated by HHH1.   
      
   This ultimately means that the requirement itself   
   is incorrect and DD simulated by HHH overrules   
   the requirement.   
      
   > You are just showing you don't understand the concept of requirements.   
   >   
   > Since you never worry about meeting requirements, that seems just normal   
   > for you. Your problem is you don't think YOU are "accountable" to the   
   > rules, which is why you thought it was ok for you to have child porn.   
      
      
      
   --   
   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)