XPost: comp.theory, comp.ai.philosophy   
   From: NoOne@nospicedham.NoWhere.com   
      
   On 12/14/2020 2:02 PM, Kaz Kylheku wrote:   
   > On 2020-12-14, olcott  wrote:   
   >> On 12/14/2020 9:32 AM, Malcolm McLean wrote:   
   >>> On Monday, 14 December 2020 at 15:16:13 UTC, olcott wrote:   
   >>>> On 12/14/2020 8:48 AM, André G. Isaak wrote:   
   >>>>> On 2020-12-14 07:25, olcott wrote:   
   >>>>>> On 12/12/2020 2:37 PM, André G. Isaak wrote:   
   >>>>>>> On 2020-12-12 13:01, olcott wrote:   
   >>>>>>>> On 12/12/2020 1:40 PM, André G. Isaak wrote:   
   >>>>>>>>> On 2020-12-12 12:25, olcott wrote:   
   >>>>>>>>>> On 12/12/2020 1:13 PM, André G. Isaak wrote:   
   >>>>>>>>>>> On 2020-12-12 12:08, olcott wrote:   
   >>>>>>>>>>>> On 12/12/2020 1:00 PM, André G. Isaak wrote:   
   >>>>>>>>>>>>> On 2020-12-12 11:26, olcott wrote:   
   >>>>>>>>>>>>>> On 12/12/2020 12:08 PM, André G. Isaak wrote:   
   >>>>>>>>>>>>>>> On 2020-12-12 10:45, olcott wrote:   
   >>>>>>>>>>>>>>>> On 12/12/2020 11:40 AM, André G. Isaak wrote:   
   >>>>>>>>>>>>>>>>> On 2020-12-12 10:38, olcott wrote:   
   >>>>>>>>>>>>>>>>>> On 12/12/2020 11:12 AM, André G. Isaak wrote:   
   >>>>>>>>>>>>>>>>>>> On 2020-12-12 09:24, olcott wrote:   
   >>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>>    
   >>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>>>>> The outermost Halts() always returns a value to its   
   >>>>>>>>>>>>>>>>>>>> caller even though it must sometimes abort the   
   >>>>>>>>>>>>>>>>>>>> simulations of inner infinite invocations of itself.   
   >>>>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>>>> And since it claims to be simulating those inner   
   >>>>>>>>>>>>>>>>>>> instances and to abort those instances only in cases   
   >>>>>>>>>>>>>>>>>>> where they would not otherwise halt, it is asserting that   
   >>>>>>>>>>>>>>>>>>> there *are* inputs to Halts() which will not halt. Ergo,   
   >>>>>>>>>>>>>>>>>>> it is asserting that Halts() is *not* a decider.   
   >>>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>>> ...in those cases where it does not halt and return a   
   >>>>>>>>>>>>>>>>>> value to its caller Halts() is not a decider. On those   
   >>>>>>>>>>>>>>>>>> invocations of Halts() where it does halt and return a   
   >>>>>>>>>>>>>>>>>> value to its caller it is a decider.   
   >>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>> A program is either a decider or it isn't. There's no such   
   >>>>>>>>>>>>>>>>> thing as a program which is sometimes a decider and   
   >>>>>>>>>>>>>>>>> sometimes isn't.   
   >>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>> André   
   >>>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>>> You already know that is pure bullshit or the term "partial   
   >>>>>>>>>>>>>>>> decider" would not exist. What motive do you have for saying   
   >>>>>>>>>>>>>>>> things that you know are pure bullshit?   
   >>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>> A partial decider is not a decider. More importantly, it is   
   >>>>>>>>>>>>>>> not a "sometimes decider".   
   >>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>> A partial decider makes a correct decision for a particular   
   >>>>>>>>>>>>>>> class of inputs but may fail to halt for other inputs.   
   >>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>> Your program sometimes halts and sometimes doesn't for the   
   >>>>>>>>>>>>>>> *same* inputs. So you cannot even claim your program is a   
   >>>>>>>>>>>>>>> partial decider, let alone an actual decider.   
   >>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>> André   
   >>>>>>>>>>>>>>>   
   >>>>>>>>>>>>>>   
   >>>>>>>>>>>>>> So in other words you "believe" against logic that some   
   >>>>>>>>>>>>>> infinitely recursive invocations  return a result to their   
   >>>>>>>>>>>>>> caller. That sounds nutty to me.   
   >>>>>>>>>>>>>   
   >>>>>>>>>>>>> How you can possibly get that idea from what I wrote is utterly   
   >>>>>>>>>>>>> beyond me.   
   >>>>>>>>>>>>>   
   >>>>>>>>>>>>> I am saying that anything which has the possibility of getting   
   >>>>>>>>>>>>> caught in infinite recursion cannot return a result and   
   >>>>>>>>>>>>> therefore cannot constitute a decider.   
   >>>>>>>>>>>>>   
   >>>>>>>>>>>>> André   
   >>>>>>>>>>>>>   
   >>>>>>>>>>>>>   
   >>>>>>>>>>>>   
   >>>>>>>>>>>> Except in those cases that it has not been caught in infinite   
   >>>>>>>>>>>> recursion and does return a result to its caller.   
   >>>>>>>>>>>>   
   >>>>>>>>>>>> Alternatively a function that can and does correctly detect   
   >>>>>>>>>>>> infinite recursion on itself and return its decision to its   
   >>>>>>>>>>>> caller does not count.   
   >>>>>>>>>>>>   
   >>>>>>>>>>>> Basically you are saying that it is wrong all of the time even   
   >>>>>>>>>>>> though it is right some of the time.   
   >>>>>>>>>>>   
   >>>>>>>>>>> No. I am saying that it is not a decider. A decider *must* return   
   >>>>>>>>>>> a result for *all* inputs. That's the definition of 'decider'.   
   >>>>>>>>>>> Something that only returns results in some instances is not a   
   >>>>>>>>>>> decider. I don't know how I can make this any clearer...   
   >>>>>>>>>>>   
   >>>>>>>>>>> André   
   >>>>>>>>>>>   
   >>>>>>>>>>   
   >>>>>>>>>> The way that you are defining it when a function does correctly   
   >>>>>>>>>> decide that it has been infinitely invoked that even though this   
   >>>>>>>>>> decision is correct it does not count.   
   >>>>>>>>>>   
   >>>>>>>>>> Since a partial decider  a decider for some inputs and not for   
   >>>>>>>>>> other inputs, then this same idea can be extended to some   
   >>>>>>>>>> invocations and not all invocations, otherwise correctly deciding   
   >>>>>>>>>> infinite recursion does not count even when the decision is correct.   
   >>>>>>>>>   
   >>>>>>>>> A partial decider is not a decider any more than a half-dollar is a   
   >>>>>>>>> dollar. A partial decider is something that correctly decides some   
   >>>>>>>>> cases, not something which is a decider in some cases. Things are   
   >>>>>>>>> either deciders or they aren't.   
   >>>>>>>>>   
   >>>>>>>> A partial decider that decides the {Linz, Sipser, Kozen}   
   >>>>>>>> counter-examples refutes these three proofs.   
   >>>>>>>>   
   >>>>>>>>> That a program correctly decides some cases does not make it a   
   >>>>>>>>> decider in those cases. You could call it a partial decider, but   
   >>>>>>>>> not a decider.   
   >>>>>>>>>   
   >>>>>>>>> However, in the case of your program, you can't even call it that   
   >>>>>>>>> because it sometimes returns and other times does not return *on   
   >>>>>>>>> the same input*. A partial decider is something which decides some   
   >>>>>>>>> set of inputs and fails to decide another, *disjoint* set of   
   >>>>>>>>> inputs. Something which gets different results for the same input   
   >>>>>>>>> isn't even a function, let alone a decider or partial decider.   
   >>>>>>>>>   
   >>>>>>>>> André   
   >>>>>>>>>   
   >>>>>>>>   
   >>>>>>>> So in other words when a partial decider correctly determines that   
   >>>>>>>> it has been invoked in infinite recursion it must fix the bug in   
   >>>>>>>> this infinitely recursive invocation so that it can report its   
      
   [continued in next message]   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)