On 11/03/2023 16:52, Richard Damon wrote:
> On 3/11/23 9:53 AM, Mr Flibble wrote:
>> On 11/03/2023 14:36, Richard Damon wrote:
>>> On 3/11/23 9:26 AM, Mr Flibble wrote:
>>>> On 11/03/2023 11:58, Richard Damon wrote:
>>>>> On 3/11/23 6:20 AM, Mr Flibble wrote:
>>>>>> On 11/03/2023 01:06, Richard Damon wrote:
>>>>>>> On 3/10/23 7:17 PM, Mr Flibble wrote:
>>>>>>>> On 10/03/2023 23:38, Richard Damon wrote:
>>>>>>>>> On 3/10/23 6:26 PM, Mr Flibble wrote:
>>>>>>>>>> On 10/03/2023 22:38, olcott wrote:
>>>>>>>>>>> On 3/10/2023 4:17 PM, Mr Flibble wrote:
>>>>>>>>>>>> On 10/03/2023 21:45, olcott wrote:
>>>>>>>>>>>>> On 6/6/2004 9:11 AM, Olcott wrote:
>>>>>>>>>>>>>> One very simple transformation of the problem into a
>>>>>>>>>>>>>> solvable problem
>>>>>>>>>>>>>> is to convert the Boolean function DoesItHalt() into a
>>>>>>>>>>>>>> tertiary response:
>>>>>>>>>>>>>> True, False, Neither.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> if (DoesItHalt() == True)
>>>>>>>>>>>>>>    while(True)   // loop forever
>>>>>>>>>>>>>>      ;
>>>>>>>>>>>>>> else if (DoesItHalt() == False)
>>>>>>>>>>>>>>    return False;
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> else if  (DoesItHalt() == NeitherTrueNorFalse)
>>>>>>>>>>>>>>    return NeitherTrueNorFalse;
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So the original Halting Problem was incorrectly formed
>>>>>>>>>>>>>> specifically
>>>>>>>>>>>>>> because it was framed as a Boolean function, thus failing
>>>>>>>>>>>>>> to account
>>>>>>>>>>>>>> for possible inputs that result in a reply other than True
>>>>>>>>>>>>>> or False.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Message-ID:
>>>>>>>>>>>>> <bCFwc.13980$Gx4.2537@bgtnsc04-news.ops.worldnet.att.net>
>>>>>>>>>>>>> [Alan Turing's Halting Problem is incorrectly formed]
>>>>>>>>>>>>>
>>>>>>>>>>>>> This is my very first USENET post about the Halting Problem
>>>>>>>>>>>>> back On 6/6/2004 9:11 AM
>>>>>>>>>>>>
>>>>>>>>>>>> And yet you have reversed your position and instead of
>>>>>>>>>>>> creating a decider with a ternary result you have gone back
>>>>>>>>>>>> to returning a binary result. This was your fatal mistake, a
>>>>>>>>>>>> mistake you probably made due to you naively being convinced
>>>>>>>>>>>> by the received (but erroneous) wisdom of others.
>>>>>>>>>>>>
>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> 01 int D(int (*x)())
>>>>>>>>>>> 02 {
>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>> 07 }
>>>>>>>>>>>
>>>>>>>>>>> Since D correctly simulated by H cannot possibly reach its
>>>>>>>>>>> own final
>>>>>>>>>>> state "return" instruction in any finite number is simulated
>>>>>>>>>>> steps H is
>>>>>>>>>>> necessarily correct to reject its input D as non-halting.
>>>>>>>>>>>
>>>>>>>>>>> *The simulated D cannot possibly get past its own line 03*
>>>>>>>>>>> H(D,D) simulates D(D) that calls H(D,D) to simulate itself
>>>>>>>>>>> again...
>>>>>>>>>>
>>>>>>>>>> An invalid program neither halts nor doesn't halt.
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So D can't be an invalid program as it will always either Halt
>>>>>>>>> or Not depending on the definiton of H. The only way for D to
>>>>>>>>> not be a valid program is if H isn't a valid program, and then
>>>>>>>>> H can't be a correct halt decider.
>>>>>>>>>
>>>>>>>>
>>>>>>>> WRONG.  The reason is subtle.  It isn't that D is invalid, or
>>>>>>>> that H isn't a correct halt decider, what is invalid is the
>>>>>>>> COMBINATION of D and H.  The combination is the category error
>>>>>>>> (the Impossible Program of [Strachey 1965]).
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>
>>>>>>>
>>>>>>> Not possible.
>>>>>>>
>>>>>>> Either D is or is not a program.
>>>>>>>
>>>>>>> If it is, then ALL Halt decider need to be able to decide it,
>>>>>>> even H.
>>>>>>>
>>>>>>> That comes from the meaning of **ALL**
>>>>>>
>>>>>> D is not a program as it references H which references D which
>>>>>> references H .. ad infinitum.  This recursion is a manifestation
>>>>>> of the category error present in the problem definition and is
>>>>>> only present if the halt decider is of the simulating type (only
>>>>>> SHDs can detect and report on the pathology via a third result); so:
>>>>>>
>>>>>> 1) Only SHDs can solve the halting problem;
>>>>>> 2) SHDs must have a ternary result as invalid programs neither
>>>>>> halt nor don't halt.
>>>>>>
>>>>>> This unique insight is attributable to Mr Flibble who is the only
>>>>>> person to have solved the halting problem.
>>>>>>
>>>>>> /Flibble
>>>>>>
>>>>>
>>>>> So, you don;t understand how it is setup at all.
>>>>>
>>>>> Yes, D is a program, built off the code of H, which needs to be
>>>>> program to meet the specifications.
>>>>>
>>>>> By specifications, program H is considered as a fundamental unit.
>>>>>
>>>>> D is given as an input, a finite string representation of this
>>>>> program D. All programs have a finite string repesentation.
>>>>>
>>>>> Thus, D references a copy of H, and is given a copy of the finite
>>>>> string representation of itself. Thus no "recursion of references"
>>>>> in the definition of the program or the input.
>>>>>
>>>>> The program D makes a simple copy of its input, which is a finite
>>>>> operation and then goes into its copy of the program H.
>>>>>
>>>>> Program H, to be a decider, must return an answer in a finite
>>>>> amount of time.
>>>>
>>>> A valid SHD with sufficient resources will return an answer in a
>>>> finite amount of time.
>>>
>>> Then so will D (unless the answer H gives is Halting, then for the
>>> Linz "D", D will just loop to show H wrong. For Sipser, D will just
>>> return 0 to make H wrong.
>>>
>>> You can't argue that D doesn't return due to an infinite recursion,
>>> but H does, as the only recursion possible is mutual.
>>
>> Nope. H isn't D. If D references H in such a way that infinite
>> recursion would result (i.e. D is pathological) then D is not a
>> program.  Note: *ONLY* the Flibble Signaling Simulating Halt Decider
>> can handle this situation properly.
>>
>>>
>>>>
>>>>>
>>>>> Program H doesn't "reference" the input, it was just provided as
>>>>> its input.
>>>>>
>>>>> Program H doesn't "call" D, it decides based on the representation
>>>>> of D.
>>>>>
>>>>> If H gets its self stuck in the loop you described, that just means
>>>>> that H faisl to meet its requirements. This is a known issue with
>>>>> trying to halt decide by just emulation.
>>>>
>>>> Nope. It only gets "stuck in the loop" if the input is "an
>>>> impossible program" as per [Strachey 1965] i.e. invalid input which
>>>> necessitates a halting decision of "not a program"; it is valid to
>>>> "abort" the simulation when such a "loop" is detected (where I agree
>>>> with Olcott) and return a halting decision of "not a program" (where
>>>> I disagree with Olcott).
>>>>
>>>> /Flibble
>>>
>>> And the "impossible program" is a valid program, so you are just
>>> admitting that you H can't answer for all valid programs.
>>
>> LOL. Of course the impossible program is not a valid program: you seem
>> to lack an understanding of simple English words.
>>
>>>
>>> Validity of a program is a SYNTAX decision, and D IS a valid program
>>> if H is.
>>>
>>> I guess you just don't understand what a program is.
>>>
>>> Note, YOUR definition leads to the contradiction that D IS a valid
>>> program if given to a DIFFERENT version of the decider, but isn't if
>>> given to this version.
>>>
>>> The validity of a program, as to BEING a program, is a universal truth.
>>>
>>> All you are proving is that your H can't accept *ALL* Programs, as
>>> requried by the problem definition.
>>
>> Nope. The Flibble Signaling Simulating Halt Decider can accept *ALL*
>> valid programs and *ALL* invalid programs and is capable of
>> distinguishing between the two types.
>>
>
> Nope, D uses a copy of H, modifying according to acceptable program
> modifications so D WILL be a program if H is,
>
> Note "Valid" for programs means is a set of instructions that produces a
> definitive results. Since H needs to do that, so will D, and thus D IS
> "Valid".
>
> The only "Qualification" the decider gets to use for "valid" is if it
> actually represents an actual program.
>
> Some "Descriptions" that it can be given might not meet the syntax
> requriements to be a program. Those could be rejected as "Not A
> Program", but D doesn't fall into that category.

On 11/03/2023 16:47, Jeffrey Rubard wrote:
> On Saturday, March 11, 2023 at 6:53:17 AM UTC-8, Mr Flibble wrote:
>> On 11/03/2023 14:36, Richard Damon wrote:
>>> On 3/11/23 9:26 AM, Mr Flibble wrote:
>>>> On 11/03/2023 11:58, Richard Damon wrote:
>>>>> On 3/11/23 6:20 AM, Mr Flibble wrote:
>>>>>> On 11/03/2023 01:06, Richard Damon wrote:
>>>>>>> On 3/10/23 7:17 PM, Mr Flibble wrote:
>>>>>>>> On 10/03/2023 23:38, Richard Damon wrote:
>>>>>>>>> On 3/10/23 6:26 PM, Mr Flibble wrote:
>>>>>>>>>> On 10/03/2023 22:38, olcott wrote:
>>>>>>>>>>> On 3/10/2023 4:17 PM, Mr Flibble wrote:
>>>>>>>>>>>> On 10/03/2023 21:45, olcott wrote:
>>>>>>>>>>>>> On 6/6/2004 9:11 AM, Olcott wrote:
>>>>>>>>>>>>>> One very simple transformation of the problem into a
>>>>>>>>>>>>>> solvable problem
>>>>>>>>>>>>>> is to convert the Boolean function DoesItHalt() into a
>>>>>>>>>>>>>> tertiary response:
>>>>>>>>>>>>>> True, False, Neither.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> if (DoesItHalt() == True)
>>>>>>>>>>>>>> while(True) // loop forever
>>>>>>>>>>>>>> ;
>>>>>>>>>>>>>> else if (DoesItHalt() == False)
>>>>>>>>>>>>>> return False;
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> else if (DoesItHalt() == NeitherTrueNorFalse)
>>>>>>>>>>>>>> return NeitherTrueNorFalse;
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So the original Halting Problem was incorrectly formed
>>>>>>>>>>>>>> specifically
>>>>>>>>>>>>>> because it was framed as a Boolean function, thus failing to
>>>>>>>>>>>>>> account
>>>>>>>>>>>>>> for possible inputs that result in a reply other than True
>>>>>>>>>>>>>> or False.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Message-ID:
>>>>>>>>>>>>> <bCFwc.13980$Gx4....@bgtnsc04-news.ops.worldnet.att.net>
>>>>>>>>>>>>> [Alan Turing's Halting Problem is incorrectly formed]
>>>>>>>>>>>>>
>>>>>>>>>>>>> This is my very first USENET post about the Halting Problem
>>>>>>>>>>>>> back On 6/6/2004 9:11 AM
>>>>>>>>>>>>
>>>>>>>>>>>> And yet you have reversed your position and instead of
>>>>>>>>>>>> creating a decider with a ternary result you have gone back to
>>>>>>>>>>>> returning a binary result. This was your fatal mistake, a
>>>>>>>>>>>> mistake you probably made due to you naively being convinced
>>>>>>>>>>>> by the received (but erroneous) wisdom of others.
>>>>>>>>>>>>
>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> 01 int D(int (*x)())
>>>>>>>>>>> 02 {
>>>>>>>>>>> 03 int Halt_Status = H(x, x);
>>>>>>>>>>> 04 if (Halt_Status)
>>>>>>>>>>> 05 HERE: goto HERE;
>>>>>>>>>>> 06 return Halt_Status;
>>>>>>>>>>> 07 }
>>>>>>>>>>>
>>>>>>>>>>> Since D correctly simulated by H cannot possibly reach its own
>>>>>>>>>>> final
>>>>>>>>>>> state "return" instruction in any finite number is simulated
>>>>>>>>>>> steps H is
>>>>>>>>>>> necessarily correct to reject its input D as non-halting.
>>>>>>>>>>>
>>>>>>>>>>> *The simulated D cannot possibly get past its own line 03*
>>>>>>>>>>> H(D,D) simulates D(D) that calls H(D,D) to simulate itself
>>>>>>>>>>> again...
>>>>>>>>>>
>>>>>>>>>> An invalid program neither halts nor doesn't halt.
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So D can't be an invalid program as it will always either Halt or
>>>>>>>>> Not depending on the definiton of H. The only way for D to not be
>>>>>>>>> a valid program is if H isn't a valid program, and then H can't
>>>>>>>>> be a correct halt decider.
>>>>>>>>>
>>>>>>>>
>>>>>>>> WRONG. The reason is subtle. It isn't that D is invalid, or that
>>>>>>>> H isn't a correct halt decider, what is invalid is the COMBINATION
>>>>>>>> of D and H. The combination is the category error (the Impossible
>>>>>>>> Program of [Strachey 1965]).
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>
>>>>>>>
>>>>>>> Not possible.
>>>>>>>
>>>>>>> Either D is or is not a program.
>>>>>>>
>>>>>>> If it is, then ALL Halt decider need to be able to decide it, even H.
>>>>>>>
>>>>>>> That comes from the meaning of **ALL**
>>>>>>
>>>>>> D is not a program as it references H which references D which
>>>>>> references H .. ad infinitum. This recursion is a manifestation of
>>>>>> the category error present in the problem definition and is only
>>>>>> present if the halt decider is of the simulating type (only SHDs can
>>>>>> detect and report on the pathology via a third result); so:
>>>>>>
>>>>>> 1) Only SHDs can solve the halting problem;
>>>>>> 2) SHDs must have a ternary result as invalid programs neither halt
>>>>>> nor don't halt.
>>>>>>
>>>>>> This unique insight is attributable to Mr Flibble who is the only
>>>>>> person to have solved the halting problem.
>>>>>>
>>>>>> /Flibble
>>>>>>
>>>>>
>>>>> So, you don;t understand how it is setup at all.
>>>>>
>>>>> Yes, D is a program, built off the code of H, which needs to be
>>>>> program to meet the specifications.
>>>>>
>>>>> By specifications, program H is considered as a fundamental unit.
>>>>>
>>>>> D is given as an input, a finite string representation of this
>>>>> program D. All programs have a finite string repesentation.
>>>>>
>>>>> Thus, D references a copy of H, and is given a copy of the finite
>>>>> string representation of itself. Thus no "recursion of references" in
>>>>> the definition of the program or the input.
>>>>>
>>>>> The program D makes a simple copy of its input, which is a finite
>>>>> operation and then goes into its copy of the program H.
>>>>>
>>>>> Program H, to be a decider, must return an answer in a finite amount
>>>>> of time.
>>>>
>>>> A valid SHD with sufficient resources will return an answer in a
>>>> finite amount of time.
>>>
>>> Then so will D (unless the answer H gives is Halting, then for the Linz
>>> "D", D will just loop to show H wrong. For Sipser, D will just return 0
>>> to make H wrong.
>>>
>>> You can't argue that D doesn't return due to an infinite recursion, but
>>> H does, as the only recursion possible is mutual.
>> Nope. H isn't D. If D references H in such a way that infinite recursion
>> would result (i.e. D is pathological) then D is not a program. Note:
>> *ONLY* the Flibble Signaling Simulating Halt Decider can handle this
>> situation properly.
>>>
>>>>
>>>>>
>>>>> Program H doesn't "reference" the input, it was just provided as its
>>>>> input.
>>>>>
>>>>> Program H doesn't "call" D, it decides based on the representation of D.
>>>>>
>>>>> If H gets its self stuck in the loop you described, that just means
>>>>> that H faisl to meet its requirements. This is a known issue with
>>>>> trying to halt decide by just emulation.
>>>>
>>>> Nope. It only gets "stuck in the loop" if the input is "an impossible
>>>> program" as per [Strachey 1965] i.e. invalid input which necessitates
>>>> a halting decision of "not a program"; it is valid to "abort" the
>>>> simulation when such a "loop" is detected (where I agree with Olcott)
>>>> and return a halting decision of "not a program" (where I disagree
>>>> with Olcott).
>>>>
>>>> /Flibble
>>>
>>> And the "impossible program" is a valid program, so you are just
>>> admitting that you H can't answer for all valid programs.
>> LOL. Of course the impossible program is not a valid program: you seem
>> to lack an understanding of simple English words.
>>>
>>> Validity of a program is a SYNTAX decision, and D IS a valid program if
>>> H is.
>>>
>>> I guess you just don't understand what a program is.
>>>
>>> Note, YOUR definition leads to the contradiction that D IS a valid
>>> program if given to a DIFFERENT version of the decider, but isn't if
>>> given to this version.
>>>
>>> The validity of a program, as to BEING a program, is a universal truth.
>>>
>>> All you are proving is that your H can't accept *ALL* Programs, as
>>> requried by the problem definition.
>> Nope. The Flibble Signaling Simulating Halt Decider can accept *ALL*
>> valid programs and *ALL* invalid programs and is capable of
>> distinguishing between the two types.
>>
>>>
>>> YOU FAIL.
>>
>> Projection.
>>
>> /Flibble
>
> "Could you learn some of this stuff before posting?"

On 3/11/23 12:35 PM, Mr Flibble wrote:
> On 11/03/2023 16:52, Richard Damon wrote:
>> On 3/11/23 9:53 AM, Mr Flibble wrote:
>>> On 11/03/2023 14:36, Richard Damon wrote:
>>>> On 3/11/23 9:26 AM, Mr Flibble wrote:
>>>>> On 11/03/2023 11:58, Richard Damon wrote:
>>>>>> On 3/11/23 6:20 AM, Mr Flibble wrote:
>>>>>>> On 11/03/2023 01:06, Richard Damon wrote:
>>>>>>>> On 3/10/23 7:17 PM, Mr Flibble wrote:
>>>>>>>>> On 10/03/2023 23:38, Richard Damon wrote:
>>>>>>>>>> On 3/10/23 6:26 PM, Mr Flibble wrote:
>>>>>>>>>>> On 10/03/2023 22:38, olcott wrote:
>>>>>>>>>>>> On 3/10/2023 4:17 PM, Mr Flibble wrote:
>>>>>>>>>>>>> On 10/03/2023 21:45, olcott wrote:
>>>>>>>>>>>>>> On 6/6/2004 9:11 AM, Olcott wrote:
>>>>>>>>>>>>>>> One very simple transformation of the problem into a
>>>>>>>>>>>>>>> solvable problem
>>>>>>>>>>>>>>> is to convert the Boolean function DoesItHalt() into a
>>>>>>>>>>>>>>> tertiary response:
>>>>>>>>>>>>>>> True, False, Neither.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> if (DoesItHalt() == True)
>>>>>>>>>>>>>>>    while(True)   // loop forever
>>>>>>>>>>>>>>>      ;
>>>>>>>>>>>>>>> else if (DoesItHalt() == False)
>>>>>>>>>>>>>>>    return False;
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> else if  (DoesItHalt() == NeitherTrueNorFalse)
>>>>>>>>>>>>>>>    return NeitherTrueNorFalse;
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So the original Halting Problem was incorrectly formed
>>>>>>>>>>>>>>> specifically
>>>>>>>>>>>>>>> because it was framed as a Boolean function, thus failing
>>>>>>>>>>>>>>> to account
>>>>>>>>>>>>>>> for possible inputs that result in a reply other than
>>>>>>>>>>>>>>> True or False.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Message-ID:
>>>>>>>>>>>>>> <bCFwc.13980$Gx4.2537@bgtnsc04-news.ops.worldnet.att.net>
>>>>>>>>>>>>>> [Alan Turing's Halting Problem is incorrectly formed]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This is my very first USENET post about the Halting Problem
>>>>>>>>>>>>>> back On 6/6/2004 9:11 AM
>>>>>>>>>>>>>
>>>>>>>>>>>>> And yet you have reversed your position and instead of
>>>>>>>>>>>>> creating a decider with a ternary result you have gone back
>>>>>>>>>>>>> to returning a binary result. This was your fatal mistake,
>>>>>>>>>>>>> a mistake you probably made due to you naively being
>>>>>>>>>>>>> convinced by the received (but erroneous) wisdom of others.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> 01 int D(int (*x)())
>>>>>>>>>>>> 02 {
>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>> 07 }
>>>>>>>>>>>>
>>>>>>>>>>>> Since D correctly simulated by H cannot possibly reach its
>>>>>>>>>>>> own final
>>>>>>>>>>>> state "return" instruction in any finite number is simulated
>>>>>>>>>>>> steps H is
>>>>>>>>>>>> necessarily correct to reject its input D as non-halting.
>>>>>>>>>>>>
>>>>>>>>>>>> *The simulated D cannot possibly get past its own line 03*
>>>>>>>>>>>> H(D,D) simulates D(D) that calls H(D,D) to simulate itself
>>>>>>>>>>>> again...
>>>>>>>>>>>
>>>>>>>>>>> An invalid program neither halts nor doesn't halt.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> So D can't be an invalid program as it will always either Halt
>>>>>>>>>> or Not depending on the definiton of H. The only way for D to
>>>>>>>>>> not be a valid program is if H isn't a valid program, and then
>>>>>>>>>> H can't be a correct halt decider.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> WRONG.  The reason is subtle.  It isn't that D is invalid, or
>>>>>>>>> that H isn't a correct halt decider, what is invalid is the
>>>>>>>>> COMBINATION of D and H.  The combination is the category error
>>>>>>>>> (the Impossible Program of [Strachey 1965]).
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>>
>>>>>>>> Not possible.
>>>>>>>>
>>>>>>>> Either D is or is not a program.
>>>>>>>>
>>>>>>>> If it is, then ALL Halt decider need to be able to decide it,
>>>>>>>> even H.
>>>>>>>>
>>>>>>>> That comes from the meaning of **ALL**
>>>>>>>
>>>>>>> D is not a program as it references H which references D which
>>>>>>> references H .. ad infinitum.  This recursion is a manifestation
>>>>>>> of the category error present in the problem definition and is
>>>>>>> only present if the halt decider is of the simulating type (only
>>>>>>> SHDs can detect and report on the pathology via a third result); so:
>>>>>>>
>>>>>>> 1) Only SHDs can solve the halting problem;
>>>>>>> 2) SHDs must have a ternary result as invalid programs neither
>>>>>>> halt nor don't halt.
>>>>>>>
>>>>>>> This unique insight is attributable to Mr Flibble who is the only
>>>>>>> person to have solved the halting problem.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> So, you don;t understand how it is setup at all.
>>>>>>
>>>>>> Yes, D is a program, built off the code of H, which needs to be
>>>>>> program to meet the specifications.
>>>>>>
>>>>>> By specifications, program H is considered as a fundamental unit.
>>>>>>
>>>>>> D is given as an input, a finite string representation of this
>>>>>> program D. All programs have a finite string repesentation.
>>>>>>
>>>>>> Thus, D references a copy of H, and is given a copy of the finite
>>>>>> string representation of itself. Thus no "recursion of references"
>>>>>> in the definition of the program or the input.
>>>>>>
>>>>>> The program D makes a simple copy of its input, which is a finite
>>>>>> operation and then goes into its copy of the program H.
>>>>>>
>>>>>> Program H, to be a decider, must return an answer in a finite
>>>>>> amount of time.
>>>>>
>>>>> A valid SHD with sufficient resources will return an answer in a
>>>>> finite amount of time.
>>>>
>>>> Then so will D (unless the answer H gives is Halting, then for the
>>>> Linz "D", D will just loop to show H wrong. For Sipser, D will just
>>>> return 0 to make H wrong.
>>>>
>>>> You can't argue that D doesn't return due to an infinite recursion,
>>>> but H does, as the only recursion possible is mutual.
>>>
>>> Nope. H isn't D. If D references H in such a way that infinite
>>> recursion would result (i.e. D is pathological) then D is not a
>>> program.  Note: *ONLY* the Flibble Signaling Simulating Halt Decider
>>> can handle this situation properly.
>>>
>>>>
>>>>>
>>>>>>
>>>>>> Program H doesn't "reference" the input, it was just provided as
>>>>>> its input.
>>>>>>
>>>>>> Program H doesn't "call" D, it decides based on the representation
>>>>>> of D.
>>>>>>
>>>>>> If H gets its self stuck in the loop you described, that just
>>>>>> means that H faisl to meet its requirements. This is a known issue
>>>>>> with trying to halt decide by just emulation.
>>>>>
>>>>> Nope. It only gets "stuck in the loop" if the input is "an
>>>>> impossible program" as per [Strachey 1965] i.e. invalid input which
>>>>> necessitates a halting decision of "not a program"; it is valid to
>>>>> "abort" the simulation when such a "loop" is detected (where I
>>>>> agree with Olcott) and return a halting decision of "not a program"
>>>>> (where I disagree with Olcott).
>>>>>
>>>>> /Flibble
>>>>
>>>> And the "impossible program" is a valid program, so you are just
>>>> admitting that you H can't answer for all valid programs.
>>>
>>> LOL. Of course the impossible program is not a valid program: you
>>> seem to lack an understanding of simple English words.
>>>
>>>>
>>>> Validity of a program is a SYNTAX decision, and D IS a valid program
>>>> if H is.
>>>>
>>>> I guess you just don't understand what a program is.
>>>>
>>>> Note, YOUR definition leads to the contradiction that D IS a valid
>>>> program if given to a DIFFERENT version of the decider, but isn't if
>>>> given to this version.
>>>>
>>>> The validity of a program, as to BEING a program, is a universal truth.
>>>>
>>>> All you are proving is that your H can't accept *ALL* Programs, as
>>>> requried by the problem definition.
>>>
>>> Nope. The Flibble Signaling Simulating Halt Decider can accept *ALL*
>>> valid programs and *ALL* invalid programs and is capable of
>>> distinguishing between the two types.
>>>
>>
>> Nope, D uses a copy of H, modifying according to acceptable program
>> modifications so D WILL be a program if H is,
>>
>> Note "Valid" for programs means is a set of instructions that produces
>> a definitive results. Since H needs to do that, so will D, and thus D
>> IS "Valid".
>>
>> The only "Qualification" the decider gets to use for "valid" is if it
>> actually represents an actual program.
>>
>> Some "Descriptions" that it can be given might not meet the syntax
>> requriements to be a program. Those could be rejected as "Not A
>> Program", but D doesn't fall into that category.
>
> Syntax requirements?! LOLWUT! You clearly have no clue about what you
> are talking about. This has nothing to do with "syntax" whatsoever you
> twit.
>
> /Flibble

On 11/03/2023 18:28, Richard Damon wrote:
> On 3/11/23 12:35 PM, Mr Flibble wrote:
>> On 11/03/2023 16:52, Richard Damon wrote:
>>> On 3/11/23 9:53 AM, Mr Flibble wrote:
>>>> On 11/03/2023 14:36, Richard Damon wrote:
>>>>> On 3/11/23 9:26 AM, Mr Flibble wrote:
>>>>>> On 11/03/2023 11:58, Richard Damon wrote:
>>>>>>> On 3/11/23 6:20 AM, Mr Flibble wrote:
>>>>>>>> On 11/03/2023 01:06, Richard Damon wrote:
>>>>>>>>> On 3/10/23 7:17 PM, Mr Flibble wrote:
>>>>>>>>>> On 10/03/2023 23:38, Richard Damon wrote:
>>>>>>>>>>> On 3/10/23 6:26 PM, Mr Flibble wrote:
>>>>>>>>>>>> On 10/03/2023 22:38, olcott wrote:
>>>>>>>>>>>>> On 3/10/2023 4:17 PM, Mr Flibble wrote:
>>>>>>>>>>>>>> On 10/03/2023 21:45, olcott wrote:
>>>>>>>>>>>>>>> On 6/6/2004 9:11 AM, Olcott wrote:
>>>>>>>>>>>>>>>> One very simple transformation of the problem into a
>>>>>>>>>>>>>>>> solvable problem
>>>>>>>>>>>>>>>> is to convert the Boolean function DoesItHalt() into a
>>>>>>>>>>>>>>>> tertiary response:
>>>>>>>>>>>>>>>> True, False, Neither.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> if (DoesItHalt() == True)
>>>>>>>>>>>>>>>>    while(True)   // loop forever
>>>>>>>>>>>>>>>>      ;
>>>>>>>>>>>>>>>> else if (DoesItHalt() == False)
>>>>>>>>>>>>>>>>    return False;
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> else if  (DoesItHalt() == NeitherTrueNorFalse)
>>>>>>>>>>>>>>>>    return NeitherTrueNorFalse;
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So the original Halting Problem was incorrectly formed
>>>>>>>>>>>>>>>> specifically
>>>>>>>>>>>>>>>> because it was framed as a Boolean function, thus
>>>>>>>>>>>>>>>> failing to account
>>>>>>>>>>>>>>>> for possible inputs that result in a reply other than
>>>>>>>>>>>>>>>> True or False.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Message-ID:
>>>>>>>>>>>>>>> <bCFwc.13980$Gx4.2537@bgtnsc04-news.ops.worldnet.att.net>
>>>>>>>>>>>>>>> [Alan Turing's Halting Problem is incorrectly formed]
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This is my very first USENET post about the Halting Problem
>>>>>>>>>>>>>>> back On 6/6/2004 9:11 AM
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And yet you have reversed your position and instead of
>>>>>>>>>>>>>> creating a decider with a ternary result you have gone
>>>>>>>>>>>>>> back to returning a binary result. This was your fatal
>>>>>>>>>>>>>> mistake, a mistake you probably made due to you naively
>>>>>>>>>>>>>> being convinced by the received (but erroneous) wisdom of
>>>>>>>>>>>>>> others.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> 01 int D(int (*x)())
>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>
>>>>>>>>>>>>> Since D correctly simulated by H cannot possibly reach its
>>>>>>>>>>>>> own final
>>>>>>>>>>>>> state "return" instruction in any finite number is
>>>>>>>>>>>>> simulated steps H is
>>>>>>>>>>>>> necessarily correct to reject its input D as non-halting.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *The simulated D cannot possibly get past its own line 03*
>>>>>>>>>>>>> H(D,D) simulates D(D) that calls H(D,D) to simulate itself
>>>>>>>>>>>>> again...
>>>>>>>>>>>>
>>>>>>>>>>>> An invalid program neither halts nor doesn't halt.
>>>>>>>>>>>>
>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> So D can't be an invalid program as it will always either
>>>>>>>>>>> Halt or Not depending on the definiton of H. The only way for
>>>>>>>>>>> D to not be a valid program is if H isn't a valid program,
>>>>>>>>>>> and then H can't be a correct halt decider.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> WRONG.  The reason is subtle.  It isn't that D is invalid, or
>>>>>>>>>> that H isn't a correct halt decider, what is invalid is the
>>>>>>>>>> COMBINATION of D and H.  The combination is the category error
>>>>>>>>>> (the Impossible Program of [Strachey 1965]).
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Not possible.
>>>>>>>>>
>>>>>>>>> Either D is or is not a program.
>>>>>>>>>
>>>>>>>>> If it is, then ALL Halt decider need to be able to decide it,
>>>>>>>>> even H.
>>>>>>>>>
>>>>>>>>> That comes from the meaning of **ALL**
>>>>>>>>
>>>>>>>> D is not a program as it references H which references D which
>>>>>>>> references H .. ad infinitum.  This recursion is a manifestation
>>>>>>>> of the category error present in the problem definition and is
>>>>>>>> only present if the halt decider is of the simulating type (only
>>>>>>>> SHDs can detect and report on the pathology via a third result);
>>>>>>>> so:
>>>>>>>>
>>>>>>>> 1) Only SHDs can solve the halting problem;
>>>>>>>> 2) SHDs must have a ternary result as invalid programs neither
>>>>>>>> halt nor don't halt.
>>>>>>>>
>>>>>>>> This unique insight is attributable to Mr Flibble who is the
>>>>>>>> only person to have solved the halting problem.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>
>>>>>>> So, you don;t understand how it is setup at all.
>>>>>>>
>>>>>>> Yes, D is a program, built off the code of H, which needs to be
>>>>>>> program to meet the specifications.
>>>>>>>
>>>>>>> By specifications, program H is considered as a fundamental unit.
>>>>>>>
>>>>>>> D is given as an input, a finite string representation of this
>>>>>>> program D. All programs have a finite string repesentation.
>>>>>>>
>>>>>>> Thus, D references a copy of H, and is given a copy of the finite
>>>>>>> string representation of itself. Thus no "recursion of
>>>>>>> references" in the definition of the program or the input.
>>>>>>>
>>>>>>> The program D makes a simple copy of its input, which is a finite
>>>>>>> operation and then goes into its copy of the program H.
>>>>>>>
>>>>>>> Program H, to be a decider, must return an answer in a finite
>>>>>>> amount of time.
>>>>>>
>>>>>> A valid SHD with sufficient resources will return an answer in a
>>>>>> finite amount of time.
>>>>>
>>>>> Then so will D (unless the answer H gives is Halting, then for the
>>>>> Linz "D", D will just loop to show H wrong. For Sipser, D will just
>>>>> return 0 to make H wrong.
>>>>>
>>>>> You can't argue that D doesn't return due to an infinite recursion,
>>>>> but H does, as the only recursion possible is mutual.
>>>>
>>>> Nope. H isn't D. If D references H in such a way that infinite
>>>> recursion would result (i.e. D is pathological) then D is not a
>>>> program.  Note: *ONLY* the Flibble Signaling Simulating Halt Decider
>>>> can handle this situation properly.
>>>>
>>>>>
>>>>>>
>>>>>>>
>>>>>>> Program H doesn't "reference" the input, it was just provided as
>>>>>>> its input.
>>>>>>>
>>>>>>> Program H doesn't "call" D, it decides based on the
>>>>>>> representation of D.
>>>>>>>
>>>>>>> If H gets its self stuck in the loop you described, that just
>>>>>>> means that H faisl to meet its requirements. This is a known
>>>>>>> issue with trying to halt decide by just emulation.
>>>>>>
>>>>>> Nope. It only gets "stuck in the loop" if the input is "an
>>>>>> impossible program" as per [Strachey 1965] i.e. invalid input
>>>>>> which necessitates a halting decision of "not a program"; it is
>>>>>> valid to "abort" the simulation when such a "loop" is detected
>>>>>> (where I agree with Olcott) and return a halting decision of "not
>>>>>> a program" (where I disagree with Olcott).
>>>>>>
>>>>>> /Flibble
>>>>>
>>>>> And the "impossible program" is a valid program, so you are just
>>>>> admitting that you H can't answer for all valid programs.
>>>>
>>>> LOL. Of course the impossible program is not a valid program: you
>>>> seem to lack an understanding of simple English words.
>>>>
>>>>>
>>>>> Validity of a program is a SYNTAX decision, and D IS a valid
>>>>> program if H is.
>>>>>
>>>>> I guess you just don't understand what a program is.
>>>>>
>>>>> Note, YOUR definition leads to the contradiction that D IS a valid
>>>>> program if given to a DIFFERENT version of the decider, but isn't
>>>>> if given to this version.
>>>>>
>>>>> The validity of a program, as to BEING a program, is a universal
>>>>> truth.
>>>>>
>>>>> All you are proving is that your H can't accept *ALL* Programs, as
>>>>> requried by the problem definition.
>>>>
>>>> Nope. The Flibble Signaling Simulating Halt Decider can accept *ALL*
>>>> valid programs and *ALL* invalid programs and is capable of
>>>> distinguishing between the two types.
>>>>
>>>
>>> Nope, D uses a copy of H, modifying according to acceptable program
>>> modifications so D WILL be a program if H is,
>>>
>>> Note "Valid" for programs means is a set of instructions that
>>> produces a definitive results. Since H needs to do that, so will D,
>>> and thus D IS "Valid".
>>>
>>> The only "Qualification" the decider gets to use for "valid" is if it
>>> actually represents an actual program.
>>>
>>> Some "Descriptions" that it can be given might not meet the syntax
>>> requriements to be a program. Those could be rejected as "Not A
>>> Program", but D doesn't fall into that category.
>>
>> Syntax requirements?! LOLWUT! You clearly have no clue about what you
>> are talking about. This has nothing to do with "syntax" whatsoever you
>> twit.
>>
>> /Flibble
>
> Nope, shows YOU don't know what you are talking about.
>
> The only thing that makes an input not a valid program is if it fails
> the SYNTAX check.
>
> There are no "Semantics" that define what is a valid program, only
> syntactic criteria.
>
> What the execution of the program does is Semantics, that it CAN be
> executed is syntax.

On 3/11/23 2:51 PM, Mr Flibble wrote:
> On 11/03/2023 18:28, Richard Damon wrote:
>> On 3/11/23 12:35 PM, Mr Flibble wrote:
>>> On 11/03/2023 16:52, Richard Damon wrote:
>>>> On 3/11/23 9:53 AM, Mr Flibble wrote:
>>>>> On 11/03/2023 14:36, Richard Damon wrote:
>>>>>> On 3/11/23 9:26 AM, Mr Flibble wrote:
>>>>>>> On 11/03/2023 11:58, Richard Damon wrote:
>>>>>>>> On 3/11/23 6:20 AM, Mr Flibble wrote:
>>>>>>>>> On 11/03/2023 01:06, Richard Damon wrote:
>>>>>>>>>> On 3/10/23 7:17 PM, Mr Flibble wrote:
>>>>>>>>>>> On 10/03/2023 23:38, Richard Damon wrote:
>>>>>>>>>>>> On 3/10/23 6:26 PM, Mr Flibble wrote:
>>>>>>>>>>>>> On 10/03/2023 22:38, olcott wrote:
>>>>>>>>>>>>>> On 3/10/2023 4:17 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On 10/03/2023 21:45, olcott wrote:
>>>>>>>>>>>>>>>> On 6/6/2004 9:11 AM, Olcott wrote:
>>>>>>>>>>>>>>>>> One very simple transformation of the problem into a
>>>>>>>>>>>>>>>>> solvable problem
>>>>>>>>>>>>>>>>> is to convert the Boolean function DoesItHalt() into a
>>>>>>>>>>>>>>>>> tertiary response:
>>>>>>>>>>>>>>>>> True, False, Neither.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> if (DoesItHalt() == True)
>>>>>>>>>>>>>>>>>    while(True)   // loop forever
>>>>>>>>>>>>>>>>>      ;
>>>>>>>>>>>>>>>>> else if (DoesItHalt() == False)
>>>>>>>>>>>>>>>>>    return False;
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> else if  (DoesItHalt() == NeitherTrueNorFalse)
>>>>>>>>>>>>>>>>>    return NeitherTrueNorFalse;
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So the original Halting Problem was incorrectly formed
>>>>>>>>>>>>>>>>> specifically
>>>>>>>>>>>>>>>>> because it was framed as a Boolean function, thus
>>>>>>>>>>>>>>>>> failing to account
>>>>>>>>>>>>>>>>> for possible inputs that result in a reply other than
>>>>>>>>>>>>>>>>> True or False.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Message-ID:
>>>>>>>>>>>>>>>> <bCFwc.13980$Gx4.2537@bgtnsc04-news.ops.worldnet.att.net>
>>>>>>>>>>>>>>>> [Alan Turing's Halting Problem is incorrectly formed]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This is my very first USENET post about the Halting Problem
>>>>>>>>>>>>>>>> back On 6/6/2004 9:11 AM
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And yet you have reversed your position and instead of
>>>>>>>>>>>>>>> creating a decider with a ternary result you have gone
>>>>>>>>>>>>>>> back to returning a binary result. This was your fatal
>>>>>>>>>>>>>>> mistake, a mistake you probably made due to you naively
>>>>>>>>>>>>>>> being convinced by the received (but erroneous) wisdom of
>>>>>>>>>>>>>>> others.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> 01 int D(int (*x)())
>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Since D correctly simulated by H cannot possibly reach its
>>>>>>>>>>>>>> own final
>>>>>>>>>>>>>> state "return" instruction in any finite number is
>>>>>>>>>>>>>> simulated steps H is
>>>>>>>>>>>>>> necessarily correct to reject its input D as non-halting.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *The simulated D cannot possibly get past its own line 03*
>>>>>>>>>>>>>> H(D,D) simulates D(D) that calls H(D,D) to simulate itself
>>>>>>>>>>>>>> again...
>>>>>>>>>>>>>
>>>>>>>>>>>>> An invalid program neither halts nor doesn't halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> So D can't be an invalid program as it will always either
>>>>>>>>>>>> Halt or Not depending on the definiton of H. The only way
>>>>>>>>>>>> for D to not be a valid program is if H isn't a valid
>>>>>>>>>>>> program, and then H can't be a correct halt decider.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> WRONG.  The reason is subtle.  It isn't that D is invalid, or
>>>>>>>>>>> that H isn't a correct halt decider, what is invalid is the
>>>>>>>>>>> COMBINATION of D and H.  The combination is the category
>>>>>>>>>>> error (the Impossible Program of [Strachey 1965]).
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Not possible.
>>>>>>>>>>
>>>>>>>>>> Either D is or is not a program.
>>>>>>>>>>
>>>>>>>>>> If it is, then ALL Halt decider need to be able to decide it,
>>>>>>>>>> even H.
>>>>>>>>>>
>>>>>>>>>> That comes from the meaning of **ALL**
>>>>>>>>>
>>>>>>>>> D is not a program as it references H which references D which
>>>>>>>>> references H .. ad infinitum.  This recursion is a
>>>>>>>>> manifestation of the category error present in the problem
>>>>>>>>> definition and is only present if the halt decider is of the
>>>>>>>>> simulating type (only SHDs can detect and report on the
>>>>>>>>> pathology via a third result); so:
>>>>>>>>>
>>>>>>>>> 1) Only SHDs can solve the halting problem;
>>>>>>>>> 2) SHDs must have a ternary result as invalid programs neither
>>>>>>>>> halt nor don't halt.
>>>>>>>>>
>>>>>>>>> This unique insight is attributable to Mr Flibble who is the
>>>>>>>>> only person to have solved the halting problem.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> So, you don;t understand how it is setup at all.
>>>>>>>>
>>>>>>>> Yes, D is a program, built off the code of H, which needs to be
>>>>>>>> program to meet the specifications.
>>>>>>>>
>>>>>>>> By specifications, program H is considered as a fundamental unit.
>>>>>>>>
>>>>>>>> D is given as an input, a finite string representation of this
>>>>>>>> program D. All programs have a finite string repesentation.
>>>>>>>>
>>>>>>>> Thus, D references a copy of H, and is given a copy of the
>>>>>>>> finite string representation of itself. Thus no "recursion of
>>>>>>>> references" in the definition of the program or the input.
>>>>>>>>
>>>>>>>> The program D makes a simple copy of its input, which is a
>>>>>>>> finite operation and then goes into its copy of the program H.
>>>>>>>>
>>>>>>>> Program H, to be a decider, must return an answer in a finite
>>>>>>>> amount of time.
>>>>>>>
>>>>>>> A valid SHD with sufficient resources will return an answer in a
>>>>>>> finite amount of time.
>>>>>>
>>>>>> Then so will D (unless the answer H gives is Halting, then for the
>>>>>> Linz "D", D will just loop to show H wrong. For Sipser, D will
>>>>>> just return 0 to make H wrong.
>>>>>>
>>>>>> You can't argue that D doesn't return due to an infinite
>>>>>> recursion, but H does, as the only recursion possible is mutual.
>>>>>
>>>>> Nope. H isn't D. If D references H in such a way that infinite
>>>>> recursion would result (i.e. D is pathological) then D is not a
>>>>> program.  Note: *ONLY* the Flibble Signaling Simulating Halt
>>>>> Decider can handle this situation properly.
>>>>>
>>>>>>
>>>>>>>
>>>>>>>>
>>>>>>>> Program H doesn't "reference" the input, it was just provided as
>>>>>>>> its input.
>>>>>>>>
>>>>>>>> Program H doesn't "call" D, it decides based on the
>>>>>>>> representation of D.
>>>>>>>>
>>>>>>>> If H gets its self stuck in the loop you described, that just
>>>>>>>> means that H faisl to meet its requirements. This is a known
>>>>>>>> issue with trying to halt decide by just emulation.
>>>>>>>
>>>>>>> Nope. It only gets "stuck in the loop" if the input is "an
>>>>>>> impossible program" as per [Strachey 1965] i.e. invalid input
>>>>>>> which necessitates a halting decision of "not a program"; it is
>>>>>>> valid to "abort" the simulation when such a "loop" is detected
>>>>>>> (where I agree with Olcott) and return a halting decision of "not
>>>>>>> a program" (where I disagree with Olcott).
>>>>>>>
>>>>>>> /Flibble
>>>>>>
>>>>>> And the "impossible program" is a valid program, so you are just
>>>>>> admitting that you H can't answer for all valid programs.
>>>>>
>>>>> LOL. Of course the impossible program is not a valid program: you
>>>>> seem to lack an understanding of simple English words.
>>>>>
>>>>>>
>>>>>> Validity of a program is a SYNTAX decision, and D IS a valid
>>>>>> program if H is.
>>>>>>
>>>>>> I guess you just don't understand what a program is.
>>>>>>
>>>>>> Note, YOUR definition leads to the contradiction that D IS a valid
>>>>>> program if given to a DIFFERENT version of the decider, but isn't
>>>>>> if given to this version.
>>>>>>
>>>>>> The validity of a program, as to BEING a program, is a universal
>>>>>> truth.
>>>>>>
>>>>>> All you are proving is that your H can't accept *ALL* Programs, as
>>>>>> requried by the problem definition.
>>>>>
>>>>> Nope. The Flibble Signaling Simulating Halt Decider can accept
>>>>> *ALL* valid programs and *ALL* invalid programs and is capable of
>>>>> distinguishing between the two types.
>>>>>
>>>>
>>>> Nope, D uses a copy of H, modifying according to acceptable program
>>>> modifications so D WILL be a program if H is,
>>>>
>>>> Note "Valid" for programs means is a set of instructions that
>>>> produces a definitive results. Since H needs to do that, so will D,
>>>> and thus D IS "Valid".
>>>>
>>>> The only "Qualification" the decider gets to use for "valid" is if
>>>> it actually represents an actual program.
>>>>
>>>> Some "Descriptions" that it can be given might not meet the syntax
>>>> requriements to be a program. Those could be rejected as "Not A
>>>> Program", but D doesn't fall into that category.
>>>
>>> Syntax requirements?! LOLWUT! You clearly have no clue about what you
>>> are talking about. This has nothing to do with "syntax" whatsoever
>>> you twit.
>>>
>>> /Flibble
>>
>> Nope, shows YOU don't know what you are talking about.
>>
>> The only thing that makes an input not a valid program is if it fails
>> the SYNTAX check.
>>
>> There are no "Semantics" that define what is a valid program, only
>> syntactic criteria.
>>
>> What the execution of the program does is Semantics, that it CAN be
>> executed is syntax.
>
> You have no clue! Nobody is denying that a program that can't be
> compiled due to a syntax error is invalid; in this case however the
> program is invalid for a different reason: the infinitely recursive
> relationship between the program and the halt decider, a category error.
>
> /Flibble

On 11/03/2023 20:28, Richard Damon wrote:
> On 3/11/23 2:51 PM, Mr Flibble wrote:
>> On 11/03/2023 18:28, Richard Damon wrote:
>>> On 3/11/23 12:35 PM, Mr Flibble wrote:
>>>> On 11/03/2023 16:52, Richard Damon wrote:
>>>>> On 3/11/23 9:53 AM, Mr Flibble wrote:
>>>>>> On 11/03/2023 14:36, Richard Damon wrote:
>>>>>>> On 3/11/23 9:26 AM, Mr Flibble wrote:
>>>>>>>> On 11/03/2023 11:58, Richard Damon wrote:
>>>>>>>>> On 3/11/23 6:20 AM, Mr Flibble wrote:
>>>>>>>>>> On 11/03/2023 01:06, Richard Damon wrote:
>>>>>>>>>>> On 3/10/23 7:17 PM, Mr Flibble wrote:
>>>>>>>>>>>> On 10/03/2023 23:38, Richard Damon wrote:
>>>>>>>>>>>>> On 3/10/23 6:26 PM, Mr Flibble wrote:
>>>>>>>>>>>>>> On 10/03/2023 22:38, olcott wrote:
>>>>>>>>>>>>>>> On 3/10/2023 4:17 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>> On 10/03/2023 21:45, olcott wrote:
>>>>>>>>>>>>>>>>> On 6/6/2004 9:11 AM, Olcott wrote:
>>>>>>>>>>>>>>>>>> One very simple transformation of the problem into a
>>>>>>>>>>>>>>>>>> solvable problem
>>>>>>>>>>>>>>>>>> is to convert the Boolean function DoesItHalt() into a
>>>>>>>>>>>>>>>>>> tertiary response:
>>>>>>>>>>>>>>>>>> True, False, Neither.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> if (DoesItHalt() == True)
>>>>>>>>>>>>>>>>>>    while(True)   // loop forever
>>>>>>>>>>>>>>>>>>      ;
>>>>>>>>>>>>>>>>>> else if (DoesItHalt() == False)
>>>>>>>>>>>>>>>>>>    return False;
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> else if  (DoesItHalt() == NeitherTrueNorFalse)
>>>>>>>>>>>>>>>>>>    return NeitherTrueNorFalse;
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So the original Halting Problem was incorrectly formed
>>>>>>>>>>>>>>>>>> specifically
>>>>>>>>>>>>>>>>>> because it was framed as a Boolean function, thus
>>>>>>>>>>>>>>>>>> failing to account
>>>>>>>>>>>>>>>>>> for possible inputs that result in a reply other than
>>>>>>>>>>>>>>>>>> True or False.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Message-ID:
>>>>>>>>>>>>>>>>> <bCFwc.13980$Gx4.2537@bgtnsc04-news.ops.worldnet.att.net>
>>>>>>>>>>>>>>>>> [Alan Turing's Halting Problem is incorrectly formed]
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> This is my very first USENET post about the Halting
>>>>>>>>>>>>>>>>> Problem
>>>>>>>>>>>>>>>>> back On 6/6/2004 9:11 AM
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And yet you have reversed your position and instead of
>>>>>>>>>>>>>>>> creating a decider with a ternary result you have gone
>>>>>>>>>>>>>>>> back to returning a binary result. This was your fatal
>>>>>>>>>>>>>>>> mistake, a mistake you probably made due to you naively
>>>>>>>>>>>>>>>> being convinced by the received (but erroneous) wisdom
>>>>>>>>>>>>>>>> of others.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> 01 int D(int (*x)())
>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Since D correctly simulated by H cannot possibly reach
>>>>>>>>>>>>>>> its own final
>>>>>>>>>>>>>>> state "return" instruction in any finite number is
>>>>>>>>>>>>>>> simulated steps H is
>>>>>>>>>>>>>>> necessarily correct to reject its input D as non-halting.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *The simulated D cannot possibly get past its own line 03*
>>>>>>>>>>>>>>> H(D,D) simulates D(D) that calls H(D,D) to simulate
>>>>>>>>>>>>>>> itself again...
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> An invalid program neither halts nor doesn't halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> So D can't be an invalid program as it will always either
>>>>>>>>>>>>> Halt or Not depending on the definiton of H. The only way
>>>>>>>>>>>>> for D to not be a valid program is if H isn't a valid
>>>>>>>>>>>>> program, and then H can't be a correct halt decider.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> WRONG.  The reason is subtle.  It isn't that D is invalid,
>>>>>>>>>>>> or that H isn't a correct halt decider, what is invalid is
>>>>>>>>>>>> the COMBINATION of D and H.  The combination is the category
>>>>>>>>>>>> error (the Impossible Program of [Strachey 1965]).
>>>>>>>>>>>>
>>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Not possible.
>>>>>>>>>>>
>>>>>>>>>>> Either D is or is not a program.
>>>>>>>>>>>
>>>>>>>>>>> If it is, then ALL Halt decider need to be able to decide it,
>>>>>>>>>>> even H.
>>>>>>>>>>>
>>>>>>>>>>> That comes from the meaning of **ALL**
>>>>>>>>>>
>>>>>>>>>> D is not a program as it references H which references D which
>>>>>>>>>> references H .. ad infinitum.  This recursion is a
>>>>>>>>>> manifestation of the category error present in the problem
>>>>>>>>>> definition and is only present if the halt decider is of the
>>>>>>>>>> simulating type (only SHDs can detect and report on the
>>>>>>>>>> pathology via a third result); so:
>>>>>>>>>>
>>>>>>>>>> 1) Only SHDs can solve the halting problem;
>>>>>>>>>> 2) SHDs must have a ternary result as invalid programs neither
>>>>>>>>>> halt nor don't halt.
>>>>>>>>>>
>>>>>>>>>> This unique insight is attributable to Mr Flibble who is the
>>>>>>>>>> only person to have solved the halting problem.
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So, you don;t understand how it is setup at all.
>>>>>>>>>
>>>>>>>>> Yes, D is a program, built off the code of H, which needs to be
>>>>>>>>> program to meet the specifications.
>>>>>>>>>
>>>>>>>>> By specifications, program H is considered as a fundamental unit.
>>>>>>>>>
>>>>>>>>> D is given as an input, a finite string representation of this
>>>>>>>>> program D. All programs have a finite string repesentation.
>>>>>>>>>
>>>>>>>>> Thus, D references a copy of H, and is given a copy of the
>>>>>>>>> finite string representation of itself. Thus no "recursion of
>>>>>>>>> references" in the definition of the program or the input.
>>>>>>>>>
>>>>>>>>> The program D makes a simple copy of its input, which is a
>>>>>>>>> finite operation and then goes into its copy of the program H.
>>>>>>>>>
>>>>>>>>> Program H, to be a decider, must return an answer in a finite
>>>>>>>>> amount of time.
>>>>>>>>
>>>>>>>> A valid SHD with sufficient resources will return an answer in a
>>>>>>>> finite amount of time.
>>>>>>>
>>>>>>> Then so will D (unless the answer H gives is Halting, then for
>>>>>>> the Linz "D", D will just loop to show H wrong. For Sipser, D
>>>>>>> will just return 0 to make H wrong.
>>>>>>>
>>>>>>> You can't argue that D doesn't return due to an infinite
>>>>>>> recursion, but H does, as the only recursion possible is mutual.
>>>>>>
>>>>>> Nope. H isn't D. If D references H in such a way that infinite
>>>>>> recursion would result (i.e. D is pathological) then D is not a
>>>>>> program.  Note: *ONLY* the Flibble Signaling Simulating Halt
>>>>>> Decider can handle this situation properly.
>>>>>>
>>>>>>>
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Program H doesn't "reference" the input, it was just provided
>>>>>>>>> as its input.
>>>>>>>>>
>>>>>>>>> Program H doesn't "call" D, it decides based on the
>>>>>>>>> representation of D.
>>>>>>>>>
>>>>>>>>> If H gets its self stuck in the loop you described, that just
>>>>>>>>> means that H faisl to meet its requirements. This is a known
>>>>>>>>> issue with trying to halt decide by just emulation.
>>>>>>>>
>>>>>>>> Nope. It only gets "stuck in the loop" if the input is "an
>>>>>>>> impossible program" as per [Strachey 1965] i.e. invalid input
>>>>>>>> which necessitates a halting decision of "not a program"; it is
>>>>>>>> valid to "abort" the simulation when such a "loop" is detected
>>>>>>>> (where I agree with Olcott) and return a halting decision of
>>>>>>>> "not a program" (where I disagree with Olcott).
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>
>>>>>>> And the "impossible program" is a valid program, so you are just
>>>>>>> admitting that you H can't answer for all valid programs.
>>>>>>
>>>>>> LOL. Of course the impossible program is not a valid program: you
>>>>>> seem to lack an understanding of simple English words.
>>>>>>
>>>>>>>
>>>>>>> Validity of a program is a SYNTAX decision, and D IS a valid
>>>>>>> program if H is.
>>>>>>>
>>>>>>> I guess you just don't understand what a program is.
>>>>>>>
>>>>>>> Note, YOUR definition leads to the contradiction that D IS a
>>>>>>> valid program if given to a DIFFERENT version of the decider, but
>>>>>>> isn't if given to this version.
>>>>>>>
>>>>>>> The validity of a program, as to BEING a program, is a universal
>>>>>>> truth.
>>>>>>>
>>>>>>> All you are proving is that your H can't accept *ALL* Programs,
>>>>>>> as requried by the problem definition.
>>>>>>
>>>>>> Nope. The Flibble Signaling Simulating Halt Decider can accept
>>>>>> *ALL* valid programs and *ALL* invalid programs and is capable of
>>>>>> distinguishing between the two types.
>>>>>>
>>>>>
>>>>> Nope, D uses a copy of H, modifying according to acceptable program
>>>>> modifications so D WILL be a program if H is,
>>>>>
>>>>> Note "Valid" for programs means is a set of instructions that
>>>>> produces a definitive results. Since H needs to do that, so will D,
>>>>> and thus D IS "Valid".
>>>>>
>>>>> The only "Qualification" the decider gets to use for "valid" is if
>>>>> it actually represents an actual program.
>>>>>
>>>>> Some "Descriptions" that it can be given might not meet the syntax
>>>>> requriements to be a program. Those could be rejected as "Not A
>>>>> Program", but D doesn't fall into that category.
>>>>
>>>> Syntax requirements?! LOLWUT! You clearly have no clue about what
>>>> you are talking about. This has nothing to do with "syntax"
>>>> whatsoever you twit.
>>>>
>>>> /Flibble
>>>
>>> Nope, shows YOU don't know what you are talking about.
>>>
>>> The only thing that makes an input not a valid program is if it fails
>>> the SYNTAX check.
>>>
>>> There are no "Semantics" that define what is a valid program, only
>>> syntactic criteria.
>>>
>>> What the execution of the program does is Semantics, that it CAN be
>>> executed is syntax.
>>
>> You have no clue! Nobody is denying that a program that can't be
>> compiled due to a syntax error is invalid; in this case however the
>> program is invalid for a different reason: the infinitely recursive
>> relationship between the program and the halt decider, a category error.
>>
>> /Flibble
>
> Nope, a program that goes into an infinite loop is a perfectly fine
> program.
>
> There is nothing "invalid" about the design of the program D, it just
> makes it impossible for H to give the right answer.
>
> Please point out where in the definition of a "Program" there is any
> grounds to call "D" as not valid?
>
> You are just proving that you aren't a "Troll", but an "Idiot".

On 3/11/23 4:14 PM, Mr Flibble wrote:
> On 11/03/2023 20:28, Richard Damon wrote:
>> On 3/11/23 2:51 PM, Mr Flibble wrote:
>>> On 11/03/2023 18:28, Richard Damon wrote:
>>>> On 3/11/23 12:35 PM, Mr Flibble wrote:
>>>>> On 11/03/2023 16:52, Richard Damon wrote:
>>>>>> On 3/11/23 9:53 AM, Mr Flibble wrote:
>>>>>>> On 11/03/2023 14:36, Richard Damon wrote:
>>>>>>>> On 3/11/23 9:26 AM, Mr Flibble wrote:
>>>>>>>>> On 11/03/2023 11:58, Richard Damon wrote:
>>>>>>>>>> On 3/11/23 6:20 AM, Mr Flibble wrote:
>>>>>>>>>>> On 11/03/2023 01:06, Richard Damon wrote:
>>>>>>>>>>>> On 3/10/23 7:17 PM, Mr Flibble wrote:
>>>>>>>>>>>>> On 10/03/2023 23:38, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/10/23 6:26 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On 10/03/2023 22:38, olcott wrote:
>>>>>>>>>>>>>>>> On 3/10/2023 4:17 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On 10/03/2023 21:45, olcott wrote:
>>>>>>>>>>>>>>>>>> On 6/6/2004 9:11 AM, Olcott wrote:
>>>>>>>>>>>>>>>>>>> One very simple transformation of the problem into a
>>>>>>>>>>>>>>>>>>> solvable problem
>>>>>>>>>>>>>>>>>>> is to convert the Boolean function DoesItHalt() into
>>>>>>>>>>>>>>>>>>> a tertiary response:
>>>>>>>>>>>>>>>>>>> True, False, Neither.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> if (DoesItHalt() == True)
>>>>>>>>>>>>>>>>>>>    while(True)   // loop forever
>>>>>>>>>>>>>>>>>>>      ;
>>>>>>>>>>>>>>>>>>> else if (DoesItHalt() == False)
>>>>>>>>>>>>>>>>>>>    return False;
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> else if  (DoesItHalt() == NeitherTrueNorFalse)
>>>>>>>>>>>>>>>>>>>    return NeitherTrueNorFalse;
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So the original Halting Problem was incorrectly
>>>>>>>>>>>>>>>>>>> formed specifically
>>>>>>>>>>>>>>>>>>> because it was framed as a Boolean function, thus
>>>>>>>>>>>>>>>>>>> failing to account
>>>>>>>>>>>>>>>>>>> for possible inputs that result in a reply other than
>>>>>>>>>>>>>>>>>>> True or False.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Message-ID:
>>>>>>>>>>>>>>>>>> <bCFwc.13980$Gx4.2537@bgtnsc04-news.ops.worldnet.att.net>
>>>>>>>>>>>>>>>>>> [Alan Turing's Halting Problem is incorrectly formed]
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This is my very first USENET post about the Halting
>>>>>>>>>>>>>>>>>> Problem
>>>>>>>>>>>>>>>>>> back On 6/6/2004 9:11 AM
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And yet you have reversed your position and instead of
>>>>>>>>>>>>>>>>> creating a decider with a ternary result you have gone
>>>>>>>>>>>>>>>>> back to returning a binary result. This was your fatal
>>>>>>>>>>>>>>>>> mistake, a mistake you probably made due to you naively
>>>>>>>>>>>>>>>>> being convinced by the received (but erroneous) wisdom
>>>>>>>>>>>>>>>>> of others.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> 01 int D(int (*x)())
>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>>>>>>>>> 06   return Halt_Status;
>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Since D correctly simulated by H cannot possibly reach
>>>>>>>>>>>>>>>> its own final
>>>>>>>>>>>>>>>> state "return" instruction in any finite number is
>>>>>>>>>>>>>>>> simulated steps H is
>>>>>>>>>>>>>>>> necessarily correct to reject its input D as non-halting.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *The simulated D cannot possibly get past its own line 03*
>>>>>>>>>>>>>>>> H(D,D) simulates D(D) that calls H(D,D) to simulate
>>>>>>>>>>>>>>>> itself again...
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> An invalid program neither halts nor doesn't halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So D can't be an invalid program as it will always either
>>>>>>>>>>>>>> Halt or Not depending on the definiton of H. The only way
>>>>>>>>>>>>>> for D to not be a valid program is if H isn't a valid
>>>>>>>>>>>>>> program, and then H can't be a correct halt decider.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> WRONG.  The reason is subtle.  It isn't that D is invalid,
>>>>>>>>>>>>> or that H isn't a correct halt decider, what is invalid is
>>>>>>>>>>>>> the COMBINATION of D and H.  The combination is the
>>>>>>>>>>>>> category error (the Impossible Program of [Strachey 1965]).
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Not possible.
>>>>>>>>>>>>
>>>>>>>>>>>> Either D is or is not a program.
>>>>>>>>>>>>
>>>>>>>>>>>> If it is, then ALL Halt decider need to be able to decide
>>>>>>>>>>>> it, even H.
>>>>>>>>>>>>
>>>>>>>>>>>> That comes from the meaning of **ALL**
>>>>>>>>>>>
>>>>>>>>>>> D is not a program as it references H which references D
>>>>>>>>>>> which references H .. ad infinitum.  This recursion is a
>>>>>>>>>>> manifestation of the category error present in the problem
>>>>>>>>>>> definition and is only present if the halt decider is of the
>>>>>>>>>>> simulating type (only SHDs can detect and report on the
>>>>>>>>>>> pathology via a third result); so:
>>>>>>>>>>>
>>>>>>>>>>> 1) Only SHDs can solve the halting problem;
>>>>>>>>>>> 2) SHDs must have a ternary result as invalid programs
>>>>>>>>>>> neither halt nor don't halt.
>>>>>>>>>>>
>>>>>>>>>>> This unique insight is attributable to Mr Flibble who is the
>>>>>>>>>>> only person to have solved the halting problem.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> So, you don;t understand how it is setup at all.
>>>>>>>>>>
>>>>>>>>>> Yes, D is a program, built off the code of H, which needs to
>>>>>>>>>> be program to meet the specifications.
>>>>>>>>>>
>>>>>>>>>> By specifications, program H is considered as a fundamental unit.
>>>>>>>>>>
>>>>>>>>>> D is given as an input, a finite string representation of this
>>>>>>>>>> program D. All programs have a finite string repesentation.
>>>>>>>>>>
>>>>>>>>>> Thus, D references a copy of H, and is given a copy of the
>>>>>>>>>> finite string representation of itself. Thus no "recursion of
>>>>>>>>>> references" in the definition of the program or the input.
>>>>>>>>>>
>>>>>>>>>> The program D makes a simple copy of its input, which is a
>>>>>>>>>> finite operation and then goes into its copy of the program H.
>>>>>>>>>>
>>>>>>>>>> Program H, to be a decider, must return an answer in a finite
>>>>>>>>>> amount of time.
>>>>>>>>>
>>>>>>>>> A valid SHD with sufficient resources will return an answer in
>>>>>>>>> a finite amount of time.
>>>>>>>>
>>>>>>>> Then so will D (unless the answer H gives is Halting, then for
>>>>>>>> the Linz "D", D will just loop to show H wrong. For Sipser, D
>>>>>>>> will just return 0 to make H wrong.
>>>>>>>>
>>>>>>>> You can't argue that D doesn't return due to an infinite
>>>>>>>> recursion, but H does, as the only recursion possible is mutual.
>>>>>>>
>>>>>>> Nope. H isn't D. If D references H in such a way that infinite
>>>>>>> recursion would result (i.e. D is pathological) then D is not a
>>>>>>> program.  Note: *ONLY* the Flibble Signaling Simulating Halt
>>>>>>> Decider can handle this situation properly.
>>>>>>>
>>>>>>>>
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Program H doesn't "reference" the input, it was just provided
>>>>>>>>>> as its input.
>>>>>>>>>>
>>>>>>>>>> Program H doesn't "call" D, it decides based on the
>>>>>>>>>> representation of D.
>>>>>>>>>>
>>>>>>>>>> If H gets its self stuck in the loop you described, that just
>>>>>>>>>> means that H faisl to meet its requirements. This is a known
>>>>>>>>>> issue with trying to halt decide by just emulation.
>>>>>>>>>
>>>>>>>>> Nope. It only gets "stuck in the loop" if the input is "an
>>>>>>>>> impossible program" as per [Strachey 1965] i.e. invalid input
>>>>>>>>> which necessitates a halting decision of "not a program"; it is
>>>>>>>>> valid to "abort" the simulation when such a "loop" is detected
>>>>>>>>> (where I agree with Olcott) and return a halting decision of
>>>>>>>>> "not a program" (where I disagree with Olcott).
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>> And the "impossible program" is a valid program, so you are just
>>>>>>>> admitting that you H can't answer for all valid programs.
>>>>>>>
>>>>>>> LOL. Of course the impossible program is not a valid program: you
>>>>>>> seem to lack an understanding of simple English words.
>>>>>>>
>>>>>>>>
>>>>>>>> Validity of a program is a SYNTAX decision, and D IS a valid
>>>>>>>> program if H is.
>>>>>>>>
>>>>>>>> I guess you just don't understand what a program is.
>>>>>>>>
>>>>>>>> Note, YOUR definition leads to the contradiction that D IS a
>>>>>>>> valid program if given to a DIFFERENT version of the decider,
>>>>>>>> but isn't if given to this version.
>>>>>>>>
>>>>>>>> The validity of a program, as to BEING a program, is a universal
>>>>>>>> truth.
>>>>>>>>
>>>>>>>> All you are proving is that your H can't accept *ALL* Programs,
>>>>>>>> as requried by the problem definition.
>>>>>>>
>>>>>>> Nope. The Flibble Signaling Simulating Halt Decider can accept
>>>>>>> *ALL* valid programs and *ALL* invalid programs and is capable of
>>>>>>> distinguishing between the two types.
>>>>>>>
>>>>>>
>>>>>> Nope, D uses a copy of H, modifying according to acceptable
>>>>>> program modifications so D WILL be a program if H is,
>>>>>>
>>>>>> Note "Valid" for programs means is a set of instructions that
>>>>>> produces a definitive results. Since H needs to do that, so will
>>>>>> D, and thus D IS "Valid".
>>>>>>
>>>>>> The only "Qualification" the decider gets to use for "valid" is if
>>>>>> it actually represents an actual program.
>>>>>>
>>>>>> Some "Descriptions" that it can be given might not meet the syntax
>>>>>> requriements to be a program. Those could be rejected as "Not A
>>>>>> Program", but D doesn't fall into that category.
>>>>>
>>>>> Syntax requirements?! LOLWUT! You clearly have no clue about what
>>>>> you are talking about. This has nothing to do with "syntax"
>>>>> whatsoever you twit.
>>>>>
>>>>> /Flibble
>>>>
>>>> Nope, shows YOU don't know what you are talking about.
>>>>
>>>> The only thing that makes an input not a valid program is if it
>>>> fails the SYNTAX check.
>>>>
>>>> There are no "Semantics" that define what is a valid program, only
>>>> syntactic criteria.
>>>>
>>>> What the execution of the program does is Semantics, that it CAN be
>>>> executed is syntax.
>>>
>>> You have no clue! Nobody is denying that a program that can't be
>>> compiled due to a syntax error is invalid; in this case however the
>>> program is invalid for a different reason: the infinitely recursive
>>> relationship between the program and the halt decider, a category error.
>>>
>>> /Flibble
>>
>> Nope, a program that goes into an infinite loop is a perfectly fine
>> program.
>>
>> There is nothing "invalid" about the design of the program D, it just
>> makes it impossible for H to give the right answer.
>>
>> Please point out where in the definition of a "Program" there is any
>> grounds to call "D" as not valid?
>>
>> You are just proving that you aren't a "Troll", but an "Idiot".
>
> You have no clue! You are such a beginner!
>
> First off infinite recursion and infinite loop are two different things.
>
> Secondly the infinite recursion only manifests when the halt decider is
> of the simulating type; if the halt decider is of the non-simulating
> type there is no infinite recursion as it isn't possible to even build
> the program in the first place as the program cannot even exist due to
> infinite self reference in the problem definition, a category error.
>
> Who is more idiotic? The idiot or the idiot that argues with the idiot?
>
> /Flibble

On Saturday, March 11, 2023 at 2:11:46 PM UTC-8, Richard Damon wrote:
> On 3/11/23 4:14 PM, Mr Flibble wrote:
> > On 11/03/2023 20:28, Richard Damon wrote:
> >> On 3/11/23 2:51 PM, Mr Flibble wrote:
> >>> On 11/03/2023 18:28, Richard Damon wrote:
> >>>> On 3/11/23 12:35 PM, Mr Flibble wrote:
> >>>>> On 11/03/2023 16:52, Richard Damon wrote:
> >>>>>> On 3/11/23 9:53 AM, Mr Flibble wrote:
> >>>>>>> On 11/03/2023 14:36, Richard Damon wrote:
> >>>>>>>> On 3/11/23 9:26 AM, Mr Flibble wrote:
> >>>>>>>>> On 11/03/2023 11:58, Richard Damon wrote:
> >>>>>>>>>> On 3/11/23 6:20 AM, Mr Flibble wrote:
> >>>>>>>>>>> On 11/03/2023 01:06, Richard Damon wrote:
> >>>>>>>>>>>> On 3/10/23 7:17 PM, Mr Flibble wrote:
> >>>>>>>>>>>>> On 10/03/2023 23:38, Richard Damon wrote:
> >>>>>>>>>>>>>> On 3/10/23 6:26 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>> On 10/03/2023 22:38, olcott wrote:
> >>>>>>>>>>>>>>>> On 3/10/2023 4:17 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>> On 10/03/2023 21:45, olcott wrote:
> >>>>>>>>>>>>>>>>>> On 6/6/2004 9:11 AM, Olcott wrote:
> >>>>>>>>>>>>>>>>>>> One very simple transformation of the problem into a
> >>>>>>>>>>>>>>>>>>> solvable problem
> >>>>>>>>>>>>>>>>>>> is to convert the Boolean function DoesItHalt() into
> >>>>>>>>>>>>>>>>>>> a tertiary response:
> >>>>>>>>>>>>>>>>>>> True, False, Neither.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> if (DoesItHalt() == True)
> >>>>>>>>>>>>>>>>>>> while(True) // loop forever
> >>>>>>>>>>>>>>>>>>> ;
> >>>>>>>>>>>>>>>>>>> else if (DoesItHalt() == False)
> >>>>>>>>>>>>>>>>>>> return False;
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> else if (DoesItHalt() == NeitherTrueNorFalse)
> >>>>>>>>>>>>>>>>>>> return NeitherTrueNorFalse;
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> So the original Halting Problem was incorrectly
> >>>>>>>>>>>>>>>>>>> formed specifically
> >>>>>>>>>>>>>>>>>>> because it was framed as a Boolean function, thus
> >>>>>>>>>>>>>>>>>>> failing to account
> >>>>>>>>>>>>>>>>>>> for possible inputs that result in a reply other than
> >>>>>>>>>>>>>>>>>>> True or False.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Message-ID:
> >>>>>>>>>>>>>>>>>> <bCFwc.13980$Gx4....@bgtnsc04-news.ops.worldnet.att.net>
> >>>>>>>>>>>>>>>>>> [Alan Turing's Halting Problem is incorrectly formed]
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> This is my very first USENET post about the Halting
> >>>>>>>>>>>>>>>>>> Problem
> >>>>>>>>>>>>>>>>>> back On 6/6/2004 9:11 AM
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> And yet you have reversed your position and instead of
> >>>>>>>>>>>>>>>>> creating a decider with a ternary result you have gone
> >>>>>>>>>>>>>>>>> back to returning a binary result. This was your fatal
> >>>>>>>>>>>>>>>>> mistake, a mistake you probably made due to you naively
> >>>>>>>>>>>>>>>>> being convinced by the received (but erroneous) wisdom
> >>>>>>>>>>>>>>>>> of others.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> 01 int D(int (*x)())
> >>>>>>>>>>>>>>>> 02 {
> >>>>>>>>>>>>>>>> 03 int Halt_Status = H(x, x);
> >>>>>>>>>>>>>>>> 04 if (Halt_Status)
> >>>>>>>>>>>>>>>> 05 HERE: goto HERE;
> >>>>>>>>>>>>>>>> 06 return Halt_Status;
> >>>>>>>>>>>>>>>> 07 }
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Since D correctly simulated by H cannot possibly reach
> >>>>>>>>>>>>>>>> its own final
> >>>>>>>>>>>>>>>> state "return" instruction in any finite number is
> >>>>>>>>>>>>>>>> simulated steps H is
> >>>>>>>>>>>>>>>> necessarily correct to reject its input D as non-halting..
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> *The simulated D cannot possibly get past its own line 03*
> >>>>>>>>>>>>>>>> H(D,D) simulates D(D) that calls H(D,D) to simulate
> >>>>>>>>>>>>>>>> itself again...
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> An invalid program neither halts nor doesn't halt.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> So D can't be an invalid program as it will always either
> >>>>>>>>>>>>>> Halt or Not depending on the definiton of H. The only way
> >>>>>>>>>>>>>> for D to not be a valid program is if H isn't a valid
> >>>>>>>>>>>>>> program, and then H can't be a correct halt decider.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> WRONG. The reason is subtle. It isn't that D is invalid,
> >>>>>>>>>>>>> or that H isn't a correct halt decider, what is invalid is
> >>>>>>>>>>>>> the COMBINATION of D and H. The combination is the
> >>>>>>>>>>>>> category error (the Impossible Program of [Strachey 1965]).
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> Not possible.
> >>>>>>>>>>>>
> >>>>>>>>>>>> Either D is or is not a program.
> >>>>>>>>>>>>
> >>>>>>>>>>>> If it is, then ALL Halt decider need to be able to decide
> >>>>>>>>>>>> it, even H.
> >>>>>>>>>>>>
> >>>>>>>>>>>> That comes from the meaning of **ALL**
> >>>>>>>>>>>
> >>>>>>>>>>> D is not a program as it references H which references D
> >>>>>>>>>>> which references H .. ad infinitum. This recursion is a
> >>>>>>>>>>> manifestation of the category error present in the problem
> >>>>>>>>>>> definition and is only present if the halt decider is of the
> >>>>>>>>>>> simulating type (only SHDs can detect and report on the
> >>>>>>>>>>> pathology via a third result); so:
> >>>>>>>>>>>
> >>>>>>>>>>> 1) Only SHDs can solve the halting problem;
> >>>>>>>>>>> 2) SHDs must have a ternary result as invalid programs
> >>>>>>>>>>> neither halt nor don't halt.
> >>>>>>>>>>>
> >>>>>>>>>>> This unique insight is attributable to Mr Flibble who is the
> >>>>>>>>>>> only person to have solved the halting problem.
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> So, you don;t understand how it is setup at all.
> >>>>>>>>>>
> >>>>>>>>>> Yes, D is a program, built off the code of H, which needs to
> >>>>>>>>>> be program to meet the specifications.
> >>>>>>>>>>
> >>>>>>>>>> By specifications, program H is considered as a fundamental unit.
> >>>>>>>>>>
> >>>>>>>>>> D is given as an input, a finite string representation of this
> >>>>>>>>>> program D. All programs have a finite string repesentation.
> >>>>>>>>>>
> >>>>>>>>>> Thus, D references a copy of H, and is given a copy of the
> >>>>>>>>>> finite string representation of itself. Thus no "recursion of
> >>>>>>>>>> references" in the definition of the program or the input.
> >>>>>>>>>>
> >>>>>>>>>> The program D makes a simple copy of its input, which is a
> >>>>>>>>>> finite operation and then goes into its copy of the program H.
> >>>>>>>>>>
> >>>>>>>>>> Program H, to be a decider, must return an answer in a finite
> >>>>>>>>>> amount of time.
> >>>>>>>>>
> >>>>>>>>> A valid SHD with sufficient resources will return an answer in
> >>>>>>>>> a finite amount of time.
> >>>>>>>>
> >>>>>>>> Then so will D (unless the answer H gives is Halting, then for
> >>>>>>>> the Linz "D", D will just loop to show H wrong. For Sipser, D
> >>>>>>>> will just return 0 to make H wrong.
> >>>>>>>>
> >>>>>>>> You can't argue that D doesn't return due to an infinite
> >>>>>>>> recursion, but H does, as the only recursion possible is mutual.
> >>>>>>>
> >>>>>>> Nope. H isn't D. If D references H in such a way that infinite
> >>>>>>> recursion would result (i.e. D is pathological) then D is not a
> >>>>>>> program. Note: *ONLY* the Flibble Signaling Simulating Halt
> >>>>>>> Decider can handle this situation properly.
> >>>>>>>
> >>>>>>>>
> >>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> Program H doesn't "reference" the input, it was just provided
> >>>>>>>>>> as its input.
> >>>>>>>>>>
> >>>>>>>>>> Program H doesn't "call" D, it decides based on the
> >>>>>>>>>> representation of D.
> >>>>>>>>>>
> >>>>>>>>>> If H gets its self stuck in the loop you described, that just
> >>>>>>>>>> means that H faisl to meet its requirements. This is a known
> >>>>>>>>>> issue with trying to halt decide by just emulation.
> >>>>>>>>>
> >>>>>>>>> Nope. It only gets "stuck in the loop" if the input is "an
> >>>>>>>>> impossible program" as per [Strachey 1965] i.e. invalid input
> >>>>>>>>> which necessitates a halting decision of "not a program"; it is
> >>>>>>>>> valid to "abort" the simulation when such a "loop" is detected
> >>>>>>>>> (where I agree with Olcott) and return a halting decision of
> >>>>>>>>> "not a program" (where I disagree with Olcott).
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>
> >>>>>>>> And the "impossible program" is a valid program, so you are just
> >>>>>>>> admitting that you H can't answer for all valid programs.
> >>>>>>>
> >>>>>>> LOL. Of course the impossible program is not a valid program: you
> >>>>>>> seem to lack an understanding of simple English words.
> >>>>>>>
> >>>>>>>>
> >>>>>>>> Validity of a program is a SYNTAX decision, and D IS a valid
> >>>>>>>> program if H is.
> >>>>>>>>
> >>>>>>>> I guess you just don't understand what a program is.
> >>>>>>>>
> >>>>>>>> Note, YOUR definition leads to the contradiction that D IS a
> >>>>>>>> valid program if given to a DIFFERENT version of the decider,
> >>>>>>>> but isn't if given to this version.
> >>>>>>>>
> >>>>>>>> The validity of a program, as to BEING a program, is a universal
> >>>>>>>> truth.
> >>>>>>>>
> >>>>>>>> All you are proving is that your H can't accept *ALL* Programs,
> >>>>>>>> as requried by the problem definition.
> >>>>>>>
> >>>>>>> Nope. The Flibble Signaling Simulating Halt Decider can accept
> >>>>>>> *ALL* valid programs and *ALL* invalid programs and is capable of
> >>>>>>> distinguishing between the two types.
> >>>>>>>
> >>>>>>
> >>>>>> Nope, D uses a copy of H, modifying according to acceptable
> >>>>>> program modifications so D WILL be a program if H is,
> >>>>>>
> >>>>>> Note "Valid" for programs means is a set of instructions that
> >>>>>> produces a definitive results. Since H needs to do that, so will
> >>>>>> D, and thus D IS "Valid".
> >>>>>>
> >>>>>> The only "Qualification" the decider gets to use for "valid" is if
> >>>>>> it actually represents an actual program.
> >>>>>>
> >>>>>> Some "Descriptions" that it can be given might not meet the syntax
> >>>>>> requriements to be a program. Those could be rejected as "Not A
> >>>>>> Program", but D doesn't fall into that category.
> >>>>>
> >>>>> Syntax requirements?! LOLWUT! You clearly have no clue about what
> >>>>> you are talking about. This has nothing to do with "syntax"
> >>>>> whatsoever you twit.
> >>>>>
> >>>>> /Flibble
> >>>>
> >>>> Nope, shows YOU don't know what you are talking about.
> >>>>
> >>>> The only thing that makes an input not a valid program is if it
> >>>> fails the SYNTAX check.
> >>>>
> >>>> There are no "Semantics" that define what is a valid program, only
> >>>> syntactic criteria.
> >>>>
> >>>> What the execution of the program does is Semantics, that it CAN be
> >>>> executed is syntax.
> >>>
> >>> You have no clue! Nobody is denying that a program that can't be
> >>> compiled due to a syntax error is invalid; in this case however the
> >>> program is invalid for a different reason: the infinitely recursive
> >>> relationship between the program and the halt decider, a category error.
> >>>
> >>> /Flibble
> >>
> >> Nope, a program that goes into an infinite loop is a perfectly fine
> >> program.
> >>
> >> There is nothing "invalid" about the design of the program D, it just
> >> makes it impossible for H to give the right answer.
> >>
> >> Please point out where in the definition of a "Program" there is any
> >> grounds to call "D" as not valid?
> >>
> >> You are just proving that you aren't a "Troll", but an "Idiot".
> >
> > You have no clue! You are such a beginner!
> >
> > First off infinite recursion and infinite loop are two different things..
> >
> > Secondly the infinite recursion only manifests when the halt decider is
> > of the simulating type; if the halt decider is of the non-simulating
> > type there is no infinite recursion as it isn't possible to even build
> > the program in the first place as the program cannot even exist due to
> > infinite self reference in the problem definition, a category error.
> >
> > Who is more idiotic? The idiot or the idiot that argues with the idiot?
> >
> > /Flibble
> Right, which just makes the Simulating Halt Decider an incorect Halt
> Decidder, not the input somehow "invalid".
>
> And, there is NO problem building the program D, (except that it is
> impossible to have a correct H, just like for the same reason there is
> no correct Simulating Halt Decider).
>
> Any H that you build that CLAIMS to be a Halt Decider, clearly allows
> you to build a program D, and a representation for that program to give
> to D or H.
>
> There is no "infinite self reference" in the problem definition.
>
> An H is defined that claims to be correct.
>
> A D is built from it by a simple template.
>
> The Input it built by converting that program into a description.
>
> Then we can show that H must be incorrect.
>
> The exact same can be done with your "Simulating Halt Decider", and
> there is ZERO grounds to call the input "Invalid" as it was built by the
> normal construction rules of a program from the program H.
>
> The only way that D can't meet the definition of a program is for H to
> fail to meet the definition.
>
>
> As to why answer:
>
> Answer a fool according to his folly,
> or he will be wise in his own eyes.

On Tuesday, March 14, 2023 at 2:08:44 PM UTC-7, Jeffrey Rubard wrote:
> On Saturday, March 11, 2023 at 2:11:46 PM UTC-8, Richard Damon wrote:
> > On 3/11/23 4:14 PM, Mr Flibble wrote:
> > > On 11/03/2023 20:28, Richard Damon wrote:
> > >> On 3/11/23 2:51 PM, Mr Flibble wrote:
> > >>> On 11/03/2023 18:28, Richard Damon wrote:
> > >>>> On 3/11/23 12:35 PM, Mr Flibble wrote:
> > >>>>> On 11/03/2023 16:52, Richard Damon wrote:
> > >>>>>> On 3/11/23 9:53 AM, Mr Flibble wrote:
> > >>>>>>> On 11/03/2023 14:36, Richard Damon wrote:
> > >>>>>>>> On 3/11/23 9:26 AM, Mr Flibble wrote:
> > >>>>>>>>> On 11/03/2023 11:58, Richard Damon wrote:
> > >>>>>>>>>> On 3/11/23 6:20 AM, Mr Flibble wrote:
> > >>>>>>>>>>> On 11/03/2023 01:06, Richard Damon wrote:
> > >>>>>>>>>>>> On 3/10/23 7:17 PM, Mr Flibble wrote:
> > >>>>>>>>>>>>> On 10/03/2023 23:38, Richard Damon wrote:
> > >>>>>>>>>>>>>> On 3/10/23 6:26 PM, Mr Flibble wrote:
> > >>>>>>>>>>>>>>> On 10/03/2023 22:38, olcott wrote:
> > >>>>>>>>>>>>>>>> On 3/10/2023 4:17 PM, Mr Flibble wrote:
> > >>>>>>>>>>>>>>>>> On 10/03/2023 21:45, olcott wrote:
> > >>>>>>>>>>>>>>>>>> On 6/6/2004 9:11 AM, Olcott wrote:
> > >>>>>>>>>>>>>>>>>>> One very simple transformation of the problem into a
> > >>>>>>>>>>>>>>>>>>> solvable problem
> > >>>>>>>>>>>>>>>>>>> is to convert the Boolean function DoesItHalt() into
> > >>>>>>>>>>>>>>>>>>> a tertiary response:
> > >>>>>>>>>>>>>>>>>>> True, False, Neither.
> > >>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>> if (DoesItHalt() == True)
> > >>>>>>>>>>>>>>>>>>> while(True) // loop forever
> > >>>>>>>>>>>>>>>>>>> ;
> > >>>>>>>>>>>>>>>>>>> else if (DoesItHalt() == False)
> > >>>>>>>>>>>>>>>>>>> return False;
> > >>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>> else if (DoesItHalt() == NeitherTrueNorFalse)
> > >>>>>>>>>>>>>>>>>>> return NeitherTrueNorFalse;
> > >>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>> So the original Halting Problem was incorrectly
> > >>>>>>>>>>>>>>>>>>> formed specifically
> > >>>>>>>>>>>>>>>>>>> because it was framed as a Boolean function, thus
> > >>>>>>>>>>>>>>>>>>> failing to account
> > >>>>>>>>>>>>>>>>>>> for possible inputs that result in a reply other than
> > >>>>>>>>>>>>>>>>>>> True or False.
> > >>>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>> Message-ID:
> > >>>>>>>>>>>>>>>>>> <bCFwc.13980$Gx4....@bgtnsc04-news.ops.worldnet.att.net>
> > >>>>>>>>>>>>>>>>>> [Alan Turing's Halting Problem is incorrectly formed]
> > >>>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>> This is my very first USENET post about the Halting
> > >>>>>>>>>>>>>>>>>> Problem
> > >>>>>>>>>>>>>>>>>> back On 6/6/2004 9:11 AM
> > >>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>> And yet you have reversed your position and instead of
> > >>>>>>>>>>>>>>>>> creating a decider with a ternary result you have gone
> > >>>>>>>>>>>>>>>>> back to returning a binary result. This was your fatal
> > >>>>>>>>>>>>>>>>> mistake, a mistake you probably made due to you naively
> > >>>>>>>>>>>>>>>>> being convinced by the received (but erroneous) wisdom
> > >>>>>>>>>>>>>>>>> of others.
> > >>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>> /Flibble
> > >>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> 01 int D(int (*x)())
> > >>>>>>>>>>>>>>>> 02 {
> > >>>>>>>>>>>>>>>> 03 int Halt_Status = H(x, x);
> > >>>>>>>>>>>>>>>> 04 if (Halt_Status)
> > >>>>>>>>>>>>>>>> 05 HERE: goto HERE;
> > >>>>>>>>>>>>>>>> 06 return Halt_Status;
> > >>>>>>>>>>>>>>>> 07 }
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> Since D correctly simulated by H cannot possibly reach
> > >>>>>>>>>>>>>>>> its own final
> > >>>>>>>>>>>>>>>> state "return" instruction in any finite number is
> > >>>>>>>>>>>>>>>> simulated steps H is
> > >>>>>>>>>>>>>>>> necessarily correct to reject its input D as non-halting.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> *The simulated D cannot possibly get past its own line 03*
> > >>>>>>>>>>>>>>>> H(D,D) simulates D(D) that calls H(D,D) to simulate
> > >>>>>>>>>>>>>>>> itself again...
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>> An invalid program neither halts nor doesn't halt.
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>> /Flibble
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> So D can't be an invalid program as it will always either
> > >>>>>>>>>>>>>> Halt or Not depending on the definiton of H. The only way
> > >>>>>>>>>>>>>> for D to not be a valid program is if H isn't a valid
> > >>>>>>>>>>>>>> program, and then H can't be a correct halt decider.
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>> WRONG. The reason is subtle. It isn't that D is invalid,
> > >>>>>>>>>>>>> or that H isn't a correct halt decider, what is invalid is
> > >>>>>>>>>>>>> the COMBINATION of D and H. The combination is the
> > >>>>>>>>>>>>> category error (the Impossible Program of [Strachey 1965]).
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>> /Flibble
> > >>>>>>>>>>>>
> > >>>>>>>>>>>>
> > >>>>>>>>>>>> Not possible.
> > >>>>>>>>>>>>
> > >>>>>>>>>>>> Either D is or is not a program.
> > >>>>>>>>>>>>
> > >>>>>>>>>>>> If it is, then ALL Halt decider need to be able to decide
> > >>>>>>>>>>>> it, even H.
> > >>>>>>>>>>>>
> > >>>>>>>>>>>> That comes from the meaning of **ALL**
> > >>>>>>>>>>>
> > >>>>>>>>>>> D is not a program as it references H which references D
> > >>>>>>>>>>> which references H .. ad infinitum. This recursion is a
> > >>>>>>>>>>> manifestation of the category error present in the problem
> > >>>>>>>>>>> definition and is only present if the halt decider is of the
> > >>>>>>>>>>> simulating type (only SHDs can detect and report on the
> > >>>>>>>>>>> pathology via a third result); so:
> > >>>>>>>>>>>
> > >>>>>>>>>>> 1) Only SHDs can solve the halting problem;
> > >>>>>>>>>>> 2) SHDs must have a ternary result as invalid programs
> > >>>>>>>>>>> neither halt nor don't halt.
> > >>>>>>>>>>>
> > >>>>>>>>>>> This unique insight is attributable to Mr Flibble who is the
> > >>>>>>>>>>> only person to have solved the halting problem.
> > >>>>>>>>>>>
> > >>>>>>>>>>> /Flibble
> > >>>>>>>>>>>
> > >>>>>>>>>>
> > >>>>>>>>>> So, you don;t understand how it is setup at all.
> > >>>>>>>>>>
> > >>>>>>>>>> Yes, D is a program, built off the code of H, which needs to
> > >>>>>>>>>> be program to meet the specifications.
> > >>>>>>>>>>
> > >>>>>>>>>> By specifications, program H is considered as a fundamental unit.
> > >>>>>>>>>>
> > >>>>>>>>>> D is given as an input, a finite string representation of this
> > >>>>>>>>>> program D. All programs have a finite string repesentation.
> > >>>>>>>>>>
> > >>>>>>>>>> Thus, D references a copy of H, and is given a copy of the
> > >>>>>>>>>> finite string representation of itself. Thus no "recursion of
> > >>>>>>>>>> references" in the definition of the program or the input.
> > >>>>>>>>>>
> > >>>>>>>>>> The program D makes a simple copy of its input, which is a
> > >>>>>>>>>> finite operation and then goes into its copy of the program H.
> > >>>>>>>>>>
> > >>>>>>>>>> Program H, to be a decider, must return an answer in a finite
> > >>>>>>>>>> amount of time.
> > >>>>>>>>>
> > >>>>>>>>> A valid SHD with sufficient resources will return an answer in
> > >>>>>>>>> a finite amount of time.
> > >>>>>>>>
> > >>>>>>>> Then so will D (unless the answer H gives is Halting, then for
> > >>>>>>>> the Linz "D", D will just loop to show H wrong. For Sipser, D
> > >>>>>>>> will just return 0 to make H wrong.
> > >>>>>>>>
> > >>>>>>>> You can't argue that D doesn't return due to an infinite
> > >>>>>>>> recursion, but H does, as the only recursion possible is mutual.
> > >>>>>>>
> > >>>>>>> Nope. H isn't D. If D references H in such a way that infinite
> > >>>>>>> recursion would result (i.e. D is pathological) then D is not a
> > >>>>>>> program. Note: *ONLY* the Flibble Signaling Simulating Halt
> > >>>>>>> Decider can handle this situation properly.
> > >>>>>>>
> > >>>>>>>>
> > >>>>>>>>>
> > >>>>>>>>>>
> > >>>>>>>>>> Program H doesn't "reference" the input, it was just provided
> > >>>>>>>>>> as its input.
> > >>>>>>>>>>
> > >>>>>>>>>> Program H doesn't "call" D, it decides based on the
> > >>>>>>>>>> representation of D.
> > >>>>>>>>>>
> > >>>>>>>>>> If H gets its self stuck in the loop you described, that just
> > >>>>>>>>>> means that H faisl to meet its requirements. This is a known
> > >>>>>>>>>> issue with trying to halt decide by just emulation.
> > >>>>>>>>>
> > >>>>>>>>> Nope. It only gets "stuck in the loop" if the input is "an
> > >>>>>>>>> impossible program" as per [Strachey 1965] i.e. invalid input
> > >>>>>>>>> which necessitates a halting decision of "not a program"; it is
> > >>>>>>>>> valid to "abort" the simulation when such a "loop" is detected
> > >>>>>>>>> (where I agree with Olcott) and return a halting decision of
> > >>>>>>>>> "not a program" (where I disagree with Olcott).
> > >>>>>>>>>
> > >>>>>>>>> /Flibble
> > >>>>>>>>
> > >>>>>>>> And the "impossible program" is a valid program, so you are just
> > >>>>>>>> admitting that you H can't answer for all valid programs.
> > >>>>>>>
> > >>>>>>> LOL. Of course the impossible program is not a valid program: you
> > >>>>>>> seem to lack an understanding of simple English words.
> > >>>>>>>
> > >>>>>>>>
> > >>>>>>>> Validity of a program is a SYNTAX decision, and D IS a valid
> > >>>>>>>> program if H is.
> > >>>>>>>>
> > >>>>>>>> I guess you just don't understand what a program is.
> > >>>>>>>>
> > >>>>>>>> Note, YOUR definition leads to the contradiction that D IS a
> > >>>>>>>> valid program if given to a DIFFERENT version of the decider,
> > >>>>>>>> but isn't if given to this version.
> > >>>>>>>>
> > >>>>>>>> The validity of a program, as to BEING a program, is a universal
> > >>>>>>>> truth.
> > >>>>>>>>
> > >>>>>>>> All you are proving is that your H can't accept *ALL* Programs,
> > >>>>>>>> as requried by the problem definition.
> > >>>>>>>
> > >>>>>>> Nope. The Flibble Signaling Simulating Halt Decider can accept
> > >>>>>>> *ALL* valid programs and *ALL* invalid programs and is capable of
> > >>>>>>> distinguishing between the two types.
> > >>>>>>>
> > >>>>>>
> > >>>>>> Nope, D uses a copy of H, modifying according to acceptable
> > >>>>>> program modifications so D WILL be a program if H is,
> > >>>>>>
> > >>>>>> Note "Valid" for programs means is a set of instructions that
> > >>>>>> produces a definitive results. Since H needs to do that, so will
> > >>>>>> D, and thus D IS "Valid".
> > >>>>>>
> > >>>>>> The only "Qualification" the decider gets to use for "valid" is if
> > >>>>>> it actually represents an actual program.
> > >>>>>>
> > >>>>>> Some "Descriptions" that it can be given might not meet the syntax
> > >>>>>> requriements to be a program. Those could be rejected as "Not A
> > >>>>>> Program", but D doesn't fall into that category.
> > >>>>>
> > >>>>> Syntax requirements?! LOLWUT! You clearly have no clue about what
> > >>>>> you are talking about. This has nothing to do with "syntax"
> > >>>>> whatsoever you twit.
> > >>>>>
> > >>>>> /Flibble
> > >>>>
> > >>>> Nope, shows YOU don't know what you are talking about.
> > >>>>
> > >>>> The only thing that makes an input not a valid program is if it
> > >>>> fails the SYNTAX check.
> > >>>>
> > >>>> There are no "Semantics" that define what is a valid program, only
> > >>>> syntactic criteria.
> > >>>>
> > >>>> What the execution of the program does is Semantics, that it CAN be
> > >>>> executed is syntax.
> > >>>
> > >>> You have no clue! Nobody is denying that a program that can't be
> > >>> compiled due to a syntax error is invalid; in this case however the
> > >>> program is invalid for a different reason: the infinitely recursive
> > >>> relationship between the program and the halt decider, a category error.
> > >>>
> > >>> /Flibble
> > >>
> > >> Nope, a program that goes into an infinite loop is a perfectly fine
> > >> program.
> > >>
> > >> There is nothing "invalid" about the design of the program D, it just
> > >> makes it impossible for H to give the right answer.
> > >>
> > >> Please point out where in the definition of a "Program" there is any
> > >> grounds to call "D" as not valid?
> > >>
> > >> You are just proving that you aren't a "Troll", but an "Idiot".
> > >
> > > You have no clue! You are such a beginner!
> > >
> > > First off infinite recursion and infinite loop are two different things.
> > >
> > > Secondly the infinite recursion only manifests when the halt decider is
> > > of the simulating type; if the halt decider is of the non-simulating
> > > type there is no infinite recursion as it isn't possible to even build
> > > the program in the first place as the program cannot even exist due to
> > > infinite self reference in the problem definition, a category error.
> > >
> > > Who is more idiotic? The idiot or the idiot that argues with the idiot?
> > >
> > > /Flibble
> > Right, which just makes the Simulating Halt Decider an incorect Halt
> > Decidder, not the input somehow "invalid".
> >
> > And, there is NO problem building the program D, (except that it is
> > impossible to have a correct H, just like for the same reason there is
> > no correct Simulating Halt Decider).
> >
> > Any H that you build that CLAIMS to be a Halt Decider, clearly allows
> > you to build a program D, and a representation for that program to give
> > to D or H.
> >
> > There is no "infinite self reference" in the problem definition.
> >
> > An H is defined that claims to be correct.
> >
> > A D is built from it by a simple template.
> >
> > The Input it built by converting that program into a description.
> >
> > Then we can show that H must be incorrect.
> >
> > The exact same can be done with your "Simulating Halt Decider", and
> > there is ZERO grounds to call the input "Invalid" as it was built by the
> > normal construction rules of a program from the program H.
> >
> > The only way that D can't meet the definition of a program is for H to
> > fail to meet the definition.
> >
> >
> > As to why answer:
> >
> > Answer a fool according to his folly,
> > or he will be wise in his own eyes.
> "I seem to remember formal logicians disrespect this 'riddle' to a man or woman."

On Tuesday, March 14, 2023 at 2:09:26 PM UTC-7, Jeffrey Rubard wrote:
> On Tuesday, March 14, 2023 at 2:08:44 PM UTC-7, Jeffrey Rubard wrote:
> > On Saturday, March 11, 2023 at 2:11:46 PM UTC-8, Richard Damon wrote:
> > > On 3/11/23 4:14 PM, Mr Flibble wrote:
> > > > On 11/03/2023 20:28, Richard Damon wrote:
> > > >> On 3/11/23 2:51 PM, Mr Flibble wrote:
> > > >>> On 11/03/2023 18:28, Richard Damon wrote:
> > > >>>> On 3/11/23 12:35 PM, Mr Flibble wrote:
> > > >>>>> On 11/03/2023 16:52, Richard Damon wrote:
> > > >>>>>> On 3/11/23 9:53 AM, Mr Flibble wrote:
> > > >>>>>>> On 11/03/2023 14:36, Richard Damon wrote:
> > > >>>>>>>> On 3/11/23 9:26 AM, Mr Flibble wrote:
> > > >>>>>>>>> On 11/03/2023 11:58, Richard Damon wrote:
> > > >>>>>>>>>> On 3/11/23 6:20 AM, Mr Flibble wrote:
> > > >>>>>>>>>>> On 11/03/2023 01:06, Richard Damon wrote:
> > > >>>>>>>>>>>> On 3/10/23 7:17 PM, Mr Flibble wrote:
> > > >>>>>>>>>>>>> On 10/03/2023 23:38, Richard Damon wrote:
> > > >>>>>>>>>>>>>> On 3/10/23 6:26 PM, Mr Flibble wrote:
> > > >>>>>>>>>>>>>>> On 10/03/2023 22:38, olcott wrote:
> > > >>>>>>>>>>>>>>>> On 3/10/2023 4:17 PM, Mr Flibble wrote:
> > > >>>>>>>>>>>>>>>>> On 10/03/2023 21:45, olcott wrote:
> > > >>>>>>>>>>>>>>>>>> On 6/6/2004 9:11 AM, Olcott wrote:
> > > >>>>>>>>>>>>>>>>>>> One very simple transformation of the problem into a
> > > >>>>>>>>>>>>>>>>>>> solvable problem
> > > >>>>>>>>>>>>>>>>>>> is to convert the Boolean function DoesItHalt() into
> > > >>>>>>>>>>>>>>>>>>> a tertiary response:
> > > >>>>>>>>>>>>>>>>>>> True, False, Neither.
> > > >>>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>>> if (DoesItHalt() == True)
> > > >>>>>>>>>>>>>>>>>>> while(True) // loop forever
> > > >>>>>>>>>>>>>>>>>>> ;
> > > >>>>>>>>>>>>>>>>>>> else if (DoesItHalt() == False)
> > > >>>>>>>>>>>>>>>>>>> return False;
> > > >>>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>>> else if (DoesItHalt() == NeitherTrueNorFalse)
> > > >>>>>>>>>>>>>>>>>>> return NeitherTrueNorFalse;
> > > >>>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>>> So the original Halting Problem was incorrectly
> > > >>>>>>>>>>>>>>>>>>> formed specifically
> > > >>>>>>>>>>>>>>>>>>> because it was framed as a Boolean function, thus
> > > >>>>>>>>>>>>>>>>>>> failing to account
> > > >>>>>>>>>>>>>>>>>>> for possible inputs that result in a reply other than
> > > >>>>>>>>>>>>>>>>>>> True or False.
> > > >>>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>> Message-ID:
> > > >>>>>>>>>>>>>>>>>> <bCFwc.13980$Gx4....@bgtnsc04-news.ops.worldnet.att.net>
> > > >>>>>>>>>>>>>>>>>> [Alan Turing's Halting Problem is incorrectly formed]
> > > >>>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>>> This is my very first USENET post about the Halting
> > > >>>>>>>>>>>>>>>>>> Problem
> > > >>>>>>>>>>>>>>>>>> back On 6/6/2004 9:11 AM
> > > >>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>> And yet you have reversed your position and instead of
> > > >>>>>>>>>>>>>>>>> creating a decider with a ternary result you have gone
> > > >>>>>>>>>>>>>>>>> back to returning a binary result. This was your fatal
> > > >>>>>>>>>>>>>>>>> mistake, a mistake you probably made due to you naively
> > > >>>>>>>>>>>>>>>>> being convinced by the received (but erroneous) wisdom
> > > >>>>>>>>>>>>>>>>> of others.
> > > >>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>> /Flibble
> > > >>>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>> 01 int D(int (*x)())
> > > >>>>>>>>>>>>>>>> 02 {
> > > >>>>>>>>>>>>>>>> 03 int Halt_Status = H(x, x);
> > > >>>>>>>>>>>>>>>> 04 if (Halt_Status)
> > > >>>>>>>>>>>>>>>> 05 HERE: goto HERE;
> > > >>>>>>>>>>>>>>>> 06 return Halt_Status;
> > > >>>>>>>>>>>>>>>> 07 }
> > > >>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>> Since D correctly simulated by H cannot possibly reach
> > > >>>>>>>>>>>>>>>> its own final
> > > >>>>>>>>>>>>>>>> state "return" instruction in any finite number is
> > > >>>>>>>>>>>>>>>> simulated steps H is
> > > >>>>>>>>>>>>>>>> necessarily correct to reject its input D as non-halting.
> > > >>>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>> *The simulated D cannot possibly get past its own line 03*
> > > >>>>>>>>>>>>>>>> H(D,D) simulates D(D) that calls H(D,D) to simulate
> > > >>>>>>>>>>>>>>>> itself again...
> > > >>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>> An invalid program neither halts nor doesn't halt.
> > > >>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>> /Flibble
> > > >>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>> So D can't be an invalid program as it will always either
> > > >>>>>>>>>>>>>> Halt or Not depending on the definiton of H. The only way
> > > >>>>>>>>>>>>>> for D to not be a valid program is if H isn't a valid
> > > >>>>>>>>>>>>>> program, and then H can't be a correct halt decider.
> > > >>>>>>>>>>>>>>
> > > >>>>>>>>>>>>>
> > > >>>>>>>>>>>>> WRONG. The reason is subtle. It isn't that D is invalid,
> > > >>>>>>>>>>>>> or that H isn't a correct halt decider, what is invalid is
> > > >>>>>>>>>>>>> the COMBINATION of D and H. The combination is the
> > > >>>>>>>>>>>>> category error (the Impossible Program of [Strachey 1965]).
> > > >>>>>>>>>>>>>
> > > >>>>>>>>>>>>> /Flibble
> > > >>>>>>>>>>>>
> > > >>>>>>>>>>>>
> > > >>>>>>>>>>>> Not possible.
> > > >>>>>>>>>>>>
> > > >>>>>>>>>>>> Either D is or is not a program.
> > > >>>>>>>>>>>>
> > > >>>>>>>>>>>> If it is, then ALL Halt decider need to be able to decide
> > > >>>>>>>>>>>> it, even H.
> > > >>>>>>>>>>>>
> > > >>>>>>>>>>>> That comes from the meaning of **ALL**
> > > >>>>>>>>>>>
> > > >>>>>>>>>>> D is not a program as it references H which references D
> > > >>>>>>>>>>> which references H .. ad infinitum. This recursion is a
> > > >>>>>>>>>>> manifestation of the category error present in the problem
> > > >>>>>>>>>>> definition and is only present if the halt decider is of the
> > > >>>>>>>>>>> simulating type (only SHDs can detect and report on the
> > > >>>>>>>>>>> pathology via a third result); so:
> > > >>>>>>>>>>>
> > > >>>>>>>>>>> 1) Only SHDs can solve the halting problem;
> > > >>>>>>>>>>> 2) SHDs must have a ternary result as invalid programs
> > > >>>>>>>>>>> neither halt nor don't halt.
> > > >>>>>>>>>>>
> > > >>>>>>>>>>> This unique insight is attributable to Mr Flibble who is the
> > > >>>>>>>>>>> only person to have solved the halting problem.
> > > >>>>>>>>>>>
> > > >>>>>>>>>>> /Flibble
> > > >>>>>>>>>>>
> > > >>>>>>>>>>
> > > >>>>>>>>>> So, you don;t understand how it is setup at all.
> > > >>>>>>>>>>
> > > >>>>>>>>>> Yes, D is a program, built off the code of H, which needs to
> > > >>>>>>>>>> be program to meet the specifications.
> > > >>>>>>>>>>
> > > >>>>>>>>>> By specifications, program H is considered as a fundamental unit.
> > > >>>>>>>>>>
> > > >>>>>>>>>> D is given as an input, a finite string representation of this
> > > >>>>>>>>>> program D. All programs have a finite string repesentation..
> > > >>>>>>>>>>
> > > >>>>>>>>>> Thus, D references a copy of H, and is given a copy of the
> > > >>>>>>>>>> finite string representation of itself. Thus no "recursion of
> > > >>>>>>>>>> references" in the definition of the program or the input.
> > > >>>>>>>>>>
> > > >>>>>>>>>> The program D makes a simple copy of its input, which is a
> > > >>>>>>>>>> finite operation and then goes into its copy of the program H.
> > > >>>>>>>>>>
> > > >>>>>>>>>> Program H, to be a decider, must return an answer in a finite
> > > >>>>>>>>>> amount of time.
> > > >>>>>>>>>
> > > >>>>>>>>> A valid SHD with sufficient resources will return an answer in
> > > >>>>>>>>> a finite amount of time.
> > > >>>>>>>>
> > > >>>>>>>> Then so will D (unless the answer H gives is Halting, then for
> > > >>>>>>>> the Linz "D", D will just loop to show H wrong. For Sipser, D
> > > >>>>>>>> will just return 0 to make H wrong.
> > > >>>>>>>>
> > > >>>>>>>> You can't argue that D doesn't return due to an infinite
> > > >>>>>>>> recursion, but H does, as the only recursion possible is mutual.
> > > >>>>>>>
> > > >>>>>>> Nope. H isn't D. If D references H in such a way that infinite
> > > >>>>>>> recursion would result (i.e. D is pathological) then D is not a
> > > >>>>>>> program. Note: *ONLY* the Flibble Signaling Simulating Halt
> > > >>>>>>> Decider can handle this situation properly.
> > > >>>>>>>
> > > >>>>>>>>
> > > >>>>>>>>>
> > > >>>>>>>>>>
> > > >>>>>>>>>> Program H doesn't "reference" the input, it was just provided
> > > >>>>>>>>>> as its input.
> > > >>>>>>>>>>
> > > >>>>>>>>>> Program H doesn't "call" D, it decides based on the
> > > >>>>>>>>>> representation of D.
> > > >>>>>>>>>>
> > > >>>>>>>>>> If H gets its self stuck in the loop you described, that just
> > > >>>>>>>>>> means that H faisl to meet its requirements. This is a known
> > > >>>>>>>>>> issue with trying to halt decide by just emulation.
> > > >>>>>>>>>
> > > >>>>>>>>> Nope. It only gets "stuck in the loop" if the input is "an
> > > >>>>>>>>> impossible program" as per [Strachey 1965] i.e. invalid input
> > > >>>>>>>>> which necessitates a halting decision of "not a program"; it is
> > > >>>>>>>>> valid to "abort" the simulation when such a "loop" is detected
> > > >>>>>>>>> (where I agree with Olcott) and return a halting decision of
> > > >>>>>>>>> "not a program" (where I disagree with Olcott).
> > > >>>>>>>>>
> > > >>>>>>>>> /Flibble
> > > >>>>>>>>
> > > >>>>>>>> And the "impossible program" is a valid program, so you are just
> > > >>>>>>>> admitting that you H can't answer for all valid programs.
> > > >>>>>>>
> > > >>>>>>> LOL. Of course the impossible program is not a valid program: you
> > > >>>>>>> seem to lack an understanding of simple English words.
> > > >>>>>>>
> > > >>>>>>>>
> > > >>>>>>>> Validity of a program is a SYNTAX decision, and D IS a valid
> > > >>>>>>>> program if H is.
> > > >>>>>>>>
> > > >>>>>>>> I guess you just don't understand what a program is.
> > > >>>>>>>>
> > > >>>>>>>> Note, YOUR definition leads to the contradiction that D IS a
> > > >>>>>>>> valid program if given to a DIFFERENT version of the decider,
> > > >>>>>>>> but isn't if given to this version.
> > > >>>>>>>>
> > > >>>>>>>> The validity of a program, as to BEING a program, is a universal
> > > >>>>>>>> truth.
> > > >>>>>>>>
> > > >>>>>>>> All you are proving is that your H can't accept *ALL* Programs,
> > > >>>>>>>> as requried by the problem definition.
> > > >>>>>>>
> > > >>>>>>> Nope. The Flibble Signaling Simulating Halt Decider can accept
> > > >>>>>>> *ALL* valid programs and *ALL* invalid programs and is capable of
> > > >>>>>>> distinguishing between the two types.
> > > >>>>>>>
> > > >>>>>>
> > > >>>>>> Nope, D uses a copy of H, modifying according to acceptable
> > > >>>>>> program modifications so D WILL be a program if H is,
> > > >>>>>>
> > > >>>>>> Note "Valid" for programs means is a set of instructions that
> > > >>>>>> produces a definitive results. Since H needs to do that, so will
> > > >>>>>> D, and thus D IS "Valid".
> > > >>>>>>
> > > >>>>>> The only "Qualification" the decider gets to use for "valid" is if
> > > >>>>>> it actually represents an actual program.
> > > >>>>>>
> > > >>>>>> Some "Descriptions" that it can be given might not meet the syntax
> > > >>>>>> requriements to be a program. Those could be rejected as "Not A
> > > >>>>>> Program", but D doesn't fall into that category.
> > > >>>>>
> > > >>>>> Syntax requirements?! LOLWUT! You clearly have no clue about what
> > > >>>>> you are talking about. This has nothing to do with "syntax"
> > > >>>>> whatsoever you twit.
> > > >>>>>
> > > >>>>> /Flibble
> > > >>>>
> > > >>>> Nope, shows YOU don't know what you are talking about.
> > > >>>>
> > > >>>> The only thing that makes an input not a valid program is if it
> > > >>>> fails the SYNTAX check.
> > > >>>>
> > > >>>> There are no "Semantics" that define what is a valid program, only
> > > >>>> syntactic criteria.
> > > >>>>
> > > >>>> What the execution of the program does is Semantics, that it CAN be
> > > >>>> executed is syntax.
> > > >>>
> > > >>> You have no clue! Nobody is denying that a program that can't be
> > > >>> compiled due to a syntax error is invalid; in this case however the
> > > >>> program is invalid for a different reason: the infinitely recursive
> > > >>> relationship between the program and the halt decider, a category error.
> > > >>>
> > > >>> /Flibble
> > > >>
> > > >> Nope, a program that goes into an infinite loop is a perfectly fine
> > > >> program.
> > > >>
> > > >> There is nothing "invalid" about the design of the program D, it just
> > > >> makes it impossible for H to give the right answer.
> > > >>
> > > >> Please point out where in the definition of a "Program" there is any
> > > >> grounds to call "D" as not valid?
> > > >>
> > > >> You are just proving that you aren't a "Troll", but an "Idiot".
> > > >
> > > > You have no clue! You are such a beginner!
> > > >
> > > > First off infinite recursion and infinite loop are two different things.
> > > >
> > > > Secondly the infinite recursion only manifests when the halt decider is
> > > > of the simulating type; if the halt decider is of the non-simulating
> > > > type there is no infinite recursion as it isn't possible to even build
> > > > the program in the first place as the program cannot even exist due to
> > > > infinite self reference in the problem definition, a category error..
> > > >
> > > > Who is more idiotic? The idiot or the idiot that argues with the idiot?
> > > >
> > > > /Flibble
> > > Right, which just makes the Simulating Halt Decider an incorect Halt
> > > Decidder, not the input somehow "invalid".
> > >
> > > And, there is NO problem building the program D, (except that it is
> > > impossible to have a correct H, just like for the same reason there is
> > > no correct Simulating Halt Decider).
> > >
> > > Any H that you build that CLAIMS to be a Halt Decider, clearly allows
> > > you to build a program D, and a representation for that program to give
> > > to D or H.
> > >
> > > There is no "infinite self reference" in the problem definition.
> > >
> > > An H is defined that claims to be correct.
> > >
> > > A D is built from it by a simple template.
> > >
> > > The Input it built by converting that program into a description.
> > >
> > > Then we can show that H must be incorrect.
> > >
> > > The exact same can be done with your "Simulating Halt Decider", and
> > > there is ZERO grounds to call the input "Invalid" as it was built by the
> > > normal construction rules of a program from the program H.
> > >
> > > The only way that D can't meet the definition of a program is for H to
> > > fail to meet the definition.
> > >
> > >
> > > As to why answer:
> > >
> > > Answer a fool according to his folly,
> > > or he will be wise in his own eyes.
> > "I seem to remember formal logicians disrespect this 'riddle' to a man or woman."
> It's taken as being criterial for your being an illogical bullshitter, etc.

On 3/18/2023 10:19 AM, Jeffrey Rubard wrote:
> On Tuesday, March 14, 2023 at 2:09:26 PM UTC-7, Jeffrey Rubard wrote:
>> On Tuesday, March 14, 2023 at 2:08:44 PM UTC-7, Jeffrey Rubard wrote:
>>> On Saturday, March 11, 2023 at 2:11:46 PM UTC-8, Richard Damon wrote:
>>>> On 3/11/23 4:14 PM, Mr Flibble wrote:
>>>>> On 11/03/2023 20:28, Richard Damon wrote:
>>>>>> On 3/11/23 2:51 PM, Mr Flibble wrote:
>>>>>>> On 11/03/2023 18:28, Richard Damon wrote:
>>>>>>>> On 3/11/23 12:35 PM, Mr Flibble wrote:
>>>>>>>>> On 11/03/2023 16:52, Richard Damon wrote:
>>>>>>>>>> On 3/11/23 9:53 AM, Mr Flibble wrote:
>>>>>>>>>>> On 11/03/2023 14:36, Richard Damon wrote:
>>>>>>>>>>>> On 3/11/23 9:26 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On 11/03/2023 11:58, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/11/23 6:20 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On 11/03/2023 01:06, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/10/23 7:17 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On 10/03/2023 23:38, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/10/23 6:26 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> On 10/03/2023 22:38, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/10/2023 4:17 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>> On 10/03/2023 21:45, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 6/6/2004 9:11 AM, Olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> One very simple transformation of the problem into a
>>>>>>>>>>>>>>>>>>>>>>> solvable problem
>>>>>>>>>>>>>>>>>>>>>>> is to convert the Boolean function DoesItHalt() into
>>>>>>>>>>>>>>>>>>>>>>> a tertiary response:
>>>>>>>>>>>>>>>>>>>>>>> True, False, Neither.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> if (DoesItHalt() == True)
>>>>>>>>>>>>>>>>>>>>>>> while(True) // loop forever
>>>>>>>>>>>>>>>>>>>>>>> ;
>>>>>>>>>>>>>>>>>>>>>>> else if (DoesItHalt() == False)
>>>>>>>>>>>>>>>>>>>>>>> return False;
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> else if (DoesItHalt() == NeitherTrueNorFalse)
>>>>>>>>>>>>>>>>>>>>>>> return NeitherTrueNorFalse;
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> So the original Halting Problem was incorrectly
>>>>>>>>>>>>>>>>>>>>>>> formed specifically
>>>>>>>>>>>>>>>>>>>>>>> because it was framed as a Boolean function, thus
>>>>>>>>>>>>>>>>>>>>>>> failing to account
>>>>>>>>>>>>>>>>>>>>>>> for possible inputs that result in a reply other than
>>>>>>>>>>>>>>>>>>>>>>> True or False.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Message-ID:
>>>>>>>>>>>>>>>>>>>>>> <bCFwc.13980$Gx4....@bgtnsc04-news.ops.worldnet.att.net>
>>>>>>>>>>>>>>>>>>>>>> [Alan Turing's Halting Problem is incorrectly formed]
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> This is my very first USENET post about the Halting
>>>>>>>>>>>>>>>>>>>>>> Problem
>>>>>>>>>>>>>>>>>>>>>> back On 6/6/2004 9:11 AM
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> And yet you have reversed your position and instead of
>>>>>>>>>>>>>>>>>>>>> creating a decider with a ternary result you have gone
>>>>>>>>>>>>>>>>>>>>> back to returning a binary result. This was your fatal
>>>>>>>>>>>>>>>>>>>>> mistake, a mistake you probably made due to you naively
>>>>>>>>>>>>>>>>>>>>> being convinced by the received (but erroneous) wisdom
>>>>>>>>>>>>>>>>>>>>> of others.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> 01 int D(int (*x)())
>>>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>>>> 03 int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>> 04 if (Halt_Status)
>>>>>>>>>>>>>>>>>>>> 05 HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>> 06 return Halt_Status;
>>>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Since D correctly simulated by H cannot possibly reach
>>>>>>>>>>>>>>>>>>>> its own final
>>>>>>>>>>>>>>>>>>>> state "return" instruction in any finite number is
>>>>>>>>>>>>>>>>>>>> simulated steps H is
>>>>>>>>>>>>>>>>>>>> necessarily correct to reject its input D as non-halting.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *The simulated D cannot possibly get past its own line 03*
>>>>>>>>>>>>>>>>>>>> H(D,D) simulates D(D) that calls H(D,D) to simulate
>>>>>>>>>>>>>>>>>>>> itself again...
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> An invalid program neither halts nor doesn't halt.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So D can't be an invalid program as it will always either
>>>>>>>>>>>>>>>>>> Halt or Not depending on the definiton of H. The only way
>>>>>>>>>>>>>>>>>> for D to not be a valid program is if H isn't a valid
>>>>>>>>>>>>>>>>>> program, and then H can't be a correct halt decider.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> WRONG. The reason is subtle. It isn't that D is invalid,
>>>>>>>>>>>>>>>>> or that H isn't a correct halt decider, what is invalid is
>>>>>>>>>>>>>>>>> the COMBINATION of D and H. The combination is the
>>>>>>>>>>>>>>>>> category error (the Impossible Program of [Strachey 1965]).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Not possible.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Either D is or is not a program.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If it is, then ALL Halt decider need to be able to decide
>>>>>>>>>>>>>>>> it, even H.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That comes from the meaning of **ALL**
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> D is not a program as it references H which references D
>>>>>>>>>>>>>>> which references H .. ad infinitum. This recursion is a
>>>>>>>>>>>>>>> manifestation of the category error present in the problem
>>>>>>>>>>>>>>> definition and is only present if the halt decider is of the
>>>>>>>>>>>>>>> simulating type (only SHDs can detect and report on the
>>>>>>>>>>>>>>> pathology via a third result); so:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> 1) Only SHDs can solve the halting problem;
>>>>>>>>>>>>>>> 2) SHDs must have a ternary result as invalid programs
>>>>>>>>>>>>>>> neither halt nor don't halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This unique insight is attributable to Mr Flibble who is the
>>>>>>>>>>>>>>> only person to have solved the halting problem.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So, you don;t understand how it is setup at all.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes, D is a program, built off the code of H, which needs to
>>>>>>>>>>>>>> be program to meet the specifications.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> By specifications, program H is considered as a fundamental unit.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> D is given as an input, a finite string representation of this
>>>>>>>>>>>>>> program D. All programs have a finite string repesentation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Thus, D references a copy of H, and is given a copy of the
>>>>>>>>>>>>>> finite string representation of itself. Thus no "recursion of
>>>>>>>>>>>>>> references" in the definition of the program or the input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The program D makes a simple copy of its input, which is a
>>>>>>>>>>>>>> finite operation and then goes into its copy of the program H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Program H, to be a decider, must return an answer in a finite
>>>>>>>>>>>>>> amount of time.
>>>>>>>>>>>>>
>>>>>>>>>>>>> A valid SHD with sufficient resources will return an answer in
>>>>>>>>>>>>> a finite amount of time.
>>>>>>>>>>>>
>>>>>>>>>>>> Then so will D (unless the answer H gives is Halting, then for
>>>>>>>>>>>> the Linz "D", D will just loop to show H wrong. For Sipser, D
>>>>>>>>>>>> will just return 0 to make H wrong.
>>>>>>>>>>>>
>>>>>>>>>>>> You can't argue that D doesn't return due to an infinite
>>>>>>>>>>>> recursion, but H does, as the only recursion possible is mutual.
>>>>>>>>>>>
>>>>>>>>>>> Nope. H isn't D. If D references H in such a way that infinite
>>>>>>>>>>> recursion would result (i.e. D is pathological) then D is not a
>>>>>>>>>>> program. Note: *ONLY* the Flibble Signaling Simulating Halt
>>>>>>>>>>> Decider can handle this situation properly.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Program H doesn't "reference" the input, it was just provided
>>>>>>>>>>>>>> as its input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Program H doesn't "call" D, it decides based on the
>>>>>>>>>>>>>> representation of D.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If H gets its self stuck in the loop you described, that just
>>>>>>>>>>>>>> means that H faisl to meet its requirements. This is a known
>>>>>>>>>>>>>> issue with trying to halt decide by just emulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope. It only gets "stuck in the loop" if the input is "an
>>>>>>>>>>>>> impossible program" as per [Strachey 1965] i.e. invalid input
>>>>>>>>>>>>> which necessitates a halting decision of "not a program"; it is
>>>>>>>>>>>>> valid to "abort" the simulation when such a "loop" is detected
>>>>>>>>>>>>> (where I agree with Olcott) and return a halting decision of
>>>>>>>>>>>>> "not a program" (where I disagree with Olcott).
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>
>>>>>>>>>>>> And the "impossible program" is a valid program, so you are just
>>>>>>>>>>>> admitting that you H can't answer for all valid programs.
>>>>>>>>>>>
>>>>>>>>>>> LOL. Of course the impossible program is not a valid program: you
>>>>>>>>>>> seem to lack an understanding of simple English words.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Validity of a program is a SYNTAX decision, and D IS a valid
>>>>>>>>>>>> program if H is.
>>>>>>>>>>>>
>>>>>>>>>>>> I guess you just don't understand what a program is.
>>>>>>>>>>>>
>>>>>>>>>>>> Note, YOUR definition leads to the contradiction that D IS a
>>>>>>>>>>>> valid program if given to a DIFFERENT version of the decider,
>>>>>>>>>>>> but isn't if given to this version.
>>>>>>>>>>>>
>>>>>>>>>>>> The validity of a program, as to BEING a program, is a universal
>>>>>>>>>>>> truth.
>>>>>>>>>>>>
>>>>>>>>>>>> All you are proving is that your H can't accept *ALL* Programs,
>>>>>>>>>>>> as requried by the problem definition.
>>>>>>>>>>>
>>>>>>>>>>> Nope. The Flibble Signaling Simulating Halt Decider can accept
>>>>>>>>>>> *ALL* valid programs and *ALL* invalid programs and is capable of
>>>>>>>>>>> distinguishing between the two types.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Nope, D uses a copy of H, modifying according to acceptable
>>>>>>>>>> program modifications so D WILL be a program if H is,
>>>>>>>>>>
>>>>>>>>>> Note "Valid" for programs means is a set of instructions that
>>>>>>>>>> produces a definitive results. Since H needs to do that, so will
>>>>>>>>>> D, and thus D IS "Valid".
>>>>>>>>>>
>>>>>>>>>> The only "Qualification" the decider gets to use for "valid" is if
>>>>>>>>>> it actually represents an actual program.
>>>>>>>>>>
>>>>>>>>>> Some "Descriptions" that it can be given might not meet the syntax
>>>>>>>>>> requriements to be a program. Those could be rejected as "Not A
>>>>>>>>>> Program", but D doesn't fall into that category.
>>>>>>>>>
>>>>>>>>> Syntax requirements?! LOLWUT! You clearly have no clue about what
>>>>>>>>> you are talking about. This has nothing to do with "syntax"
>>>>>>>>> whatsoever you twit.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>> Nope, shows YOU don't know what you are talking about.
>>>>>>>>
>>>>>>>> The only thing that makes an input not a valid program is if it
>>>>>>>> fails the SYNTAX check.
>>>>>>>>
>>>>>>>> There are no "Semantics" that define what is a valid program, only
>>>>>>>> syntactic criteria.
>>>>>>>>
>>>>>>>> What the execution of the program does is Semantics, that it CAN be
>>>>>>>> executed is syntax.
>>>>>>>
>>>>>>> You have no clue! Nobody is denying that a program that can't be
>>>>>>> compiled due to a syntax error is invalid; in this case however the
>>>>>>> program is invalid for a different reason: the infinitely recursive
>>>>>>> relationship between the program and the halt decider, a category error.
>>>>>>>
>>>>>>> /Flibble
>>>>>>
>>>>>> Nope, a program that goes into an infinite loop is a perfectly fine
>>>>>> program.
>>>>>>
>>>>>> There is nothing "invalid" about the design of the program D, it just
>>>>>> makes it impossible for H to give the right answer.
>>>>>>
>>>>>> Please point out where in the definition of a "Program" there is any
>>>>>> grounds to call "D" as not valid?
>>>>>>
>>>>>> You are just proving that you aren't a "Troll", but an "Idiot".
>>>>>
>>>>> You have no clue! You are such a beginner!
>>>>>
>>>>> First off infinite recursion and infinite loop are two different things.
>>>>>
>>>>> Secondly the infinite recursion only manifests when the halt decider is
>>>>> of the simulating type; if the halt decider is of the non-simulating
>>>>> type there is no infinite recursion as it isn't possible to even build
>>>>> the program in the first place as the program cannot even exist due to
>>>>> infinite self reference in the problem definition, a category error.
>>>>>
>>>>> Who is more idiotic? The idiot or the idiot that argues with the idiot?
>>>>>
>>>>> /Flibble
>>>> Right, which just makes the Simulating Halt Decider an incorect Halt
>>>> Decidder, not the input somehow "invalid".
>>>>
>>>> And, there is NO problem building the program D, (except that it is
>>>> impossible to have a correct H, just like for the same reason there is
>>>> no correct Simulating Halt Decider).
>>>>
>>>> Any H that you build that CLAIMS to be a Halt Decider, clearly allows
>>>> you to build a program D, and a representation for that program to give
>>>> to D or H.
>>>>
>>>> There is no "infinite self reference" in the problem definition.
>>>>
>>>> An H is defined that claims to be correct.
>>>>
>>>> A D is built from it by a simple template.
>>>>
>>>> The Input it built by converting that program into a description.
>>>>
>>>> Then we can show that H must be incorrect.
>>>>
>>>> The exact same can be done with your "Simulating Halt Decider", and
>>>> there is ZERO grounds to call the input "Invalid" as it was built by the
>>>> normal construction rules of a program from the program H.
>>>>
>>>> The only way that D can't meet the definition of a program is for H to
>>>> fail to meet the definition.
>>>>
>>>>
>>>> As to why answer:
>>>>
>>>> Answer a fool according to his folly,
>>>> or he will be wise in his own eyes.
>>> "I seem to remember formal logicians disrespect this 'riddle' to a man or woman."
>> It's taken as being criterial for your being an illogical bullshitter, etc.
>
> "If you think the Halting Problem is ill-posed, or was not definitely solved by Alan Turing... this might not be the newsgroup for you."

On 18/03/2023 15:39, olcott wrote:
> On 3/18/2023 10:19 AM, Jeffrey Rubard wrote:
>> On Tuesday, March 14, 2023 at 2:09:26 PM UTC-7, Jeffrey Rubard wrote:
>>> On Tuesday, March 14, 2023 at 2:08:44 PM UTC-7, Jeffrey Rubard wrote:
>>>> On Saturday, March 11, 2023 at 2:11:46 PM UTC-8, Richard Damon wrote:
>>>>> On 3/11/23 4:14 PM, Mr Flibble wrote:
>>>>>> On 11/03/2023 20:28, Richard Damon wrote:
>>>>>>> On 3/11/23 2:51 PM, Mr Flibble wrote:
>>>>>>>> On 11/03/2023 18:28, Richard Damon wrote:
>>>>>>>>> On 3/11/23 12:35 PM, Mr Flibble wrote:
>>>>>>>>>> On 11/03/2023 16:52, Richard Damon wrote:
>>>>>>>>>>> On 3/11/23 9:53 AM, Mr Flibble wrote:
>>>>>>>>>>>> On 11/03/2023 14:36, Richard Damon wrote:
>>>>>>>>>>>>> On 3/11/23 9:26 AM, Mr Flibble wrote:
>>>>>>>>>>>>>> On 11/03/2023 11:58, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/11/23 6:20 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>> On 11/03/2023 01:06, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/10/23 7:17 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>> On 10/03/2023 23:38, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/10/23 6:26 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>> On 10/03/2023 22:38, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/10/2023 4:17 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>> On 10/03/2023 21:45, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 6/6/2004 9:11 AM, Olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> One very simple transformation of the problem
>>>>>>>>>>>>>>>>>>>>>>>> into a
>>>>>>>>>>>>>>>>>>>>>>>> solvable problem
>>>>>>>>>>>>>>>>>>>>>>>> is to convert the Boolean function DoesItHalt()
>>>>>>>>>>>>>>>>>>>>>>>> into
>>>>>>>>>>>>>>>>>>>>>>>> a tertiary response:
>>>>>>>>>>>>>>>>>>>>>>>> True, False, Neither.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> if (DoesItHalt() == True)
>>>>>>>>>>>>>>>>>>>>>>>> while(True) // loop forever
>>>>>>>>>>>>>>>>>>>>>>>> ;
>>>>>>>>>>>>>>>>>>>>>>>> else if (DoesItHalt() == False)
>>>>>>>>>>>>>>>>>>>>>>>> return False;
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> else if (DoesItHalt() == NeitherTrueNorFalse)
>>>>>>>>>>>>>>>>>>>>>>>> return NeitherTrueNorFalse;
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So the original Halting Problem was incorrectly
>>>>>>>>>>>>>>>>>>>>>>>> formed specifically
>>>>>>>>>>>>>>>>>>>>>>>> because it was framed as a Boolean function, thus
>>>>>>>>>>>>>>>>>>>>>>>> failing to account
>>>>>>>>>>>>>>>>>>>>>>>> for possible inputs that result in a reply other
>>>>>>>>>>>>>>>>>>>>>>>> than
>>>>>>>>>>>>>>>>>>>>>>>> True or False.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Message-ID:
>>>>>>>>>>>>>>>>>>>>>>> <bCFwc.13980$Gx4....@bgtnsc04-news.ops.worldnet.att.net>
>>>>>>>>>>>>>>>>>>>>>>> [Alan Turing's Halting Problem is incorrectly
>>>>>>>>>>>>>>>>>>>>>>> formed]
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> This is my very first USENET post about the Halting
>>>>>>>>>>>>>>>>>>>>>>> Problem
>>>>>>>>>>>>>>>>>>>>>>> back On 6/6/2004 9:11 AM
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> And yet you have reversed your position and
>>>>>>>>>>>>>>>>>>>>>> instead of
>>>>>>>>>>>>>>>>>>>>>> creating a decider with a ternary result you have
>>>>>>>>>>>>>>>>>>>>>> gone
>>>>>>>>>>>>>>>>>>>>>> back to returning a binary result. This was your
>>>>>>>>>>>>>>>>>>>>>> fatal
>>>>>>>>>>>>>>>>>>>>>> mistake, a mistake you probably made due to you
>>>>>>>>>>>>>>>>>>>>>> naively
>>>>>>>>>>>>>>>>>>>>>> being convinced by the received (but erroneous)
>>>>>>>>>>>>>>>>>>>>>> wisdom
>>>>>>>>>>>>>>>>>>>>>> of others.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> 01 int D(int (*x)())
>>>>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>>>>> 03 int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>> 04 if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>> 05 HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>> 06 return Halt_Status;
>>>>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Since D correctly simulated by H cannot possibly reach
>>>>>>>>>>>>>>>>>>>>> its own final
>>>>>>>>>>>>>>>>>>>>> state "return" instruction in any finite number is
>>>>>>>>>>>>>>>>>>>>> simulated steps H is
>>>>>>>>>>>>>>>>>>>>> necessarily correct to reject its input D as
>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *The simulated D cannot possibly get past its own
>>>>>>>>>>>>>>>>>>>>> line 03*
>>>>>>>>>>>>>>>>>>>>> H(D,D) simulates D(D) that calls H(D,D) to simulate
>>>>>>>>>>>>>>>>>>>>> itself again...
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> An invalid program neither halts nor doesn't halt.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So D can't be an invalid program as it will always
>>>>>>>>>>>>>>>>>>> either
>>>>>>>>>>>>>>>>>>> Halt or Not depending on the definiton of H. The only
>>>>>>>>>>>>>>>>>>> way
>>>>>>>>>>>>>>>>>>> for D to not be a valid program is if H isn't a valid
>>>>>>>>>>>>>>>>>>> program, and then H can't be a correct halt decider.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> WRONG. The reason is subtle. It isn't that D is invalid,
>>>>>>>>>>>>>>>>>> or that H isn't a correct halt decider, what is
>>>>>>>>>>>>>>>>>> invalid is
>>>>>>>>>>>>>>>>>> the COMBINATION of D and H. The combination is the
>>>>>>>>>>>>>>>>>> category error (the Impossible Program of [Strachey
>>>>>>>>>>>>>>>>>> 1965]).
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Not possible.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Either D is or is not a program.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If it is, then ALL Halt decider need to be able to decide
>>>>>>>>>>>>>>>>> it, even H.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That comes from the meaning of **ALL**
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> D is not a program as it references H which references D
>>>>>>>>>>>>>>>> which references H .. ad infinitum. This recursion is a
>>>>>>>>>>>>>>>> manifestation of the category error present in the problem
>>>>>>>>>>>>>>>> definition and is only present if the halt decider is of
>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>> simulating type (only SHDs can detect and report on the
>>>>>>>>>>>>>>>> pathology via a third result); so:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> 1) Only SHDs can solve the halting problem;
>>>>>>>>>>>>>>>> 2) SHDs must have a ternary result as invalid programs
>>>>>>>>>>>>>>>> neither halt nor don't halt.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This unique insight is attributable to Mr Flibble who is
>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>> only person to have solved the halting problem.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So, you don;t understand how it is setup at all.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Yes, D is a program, built off the code of H, which needs to
>>>>>>>>>>>>>>> be program to meet the specifications.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> By specifications, program H is considered as a
>>>>>>>>>>>>>>> fundamental unit.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> D is given as an input, a finite string representation of
>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>> program D. All programs have a finite string repesentation.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Thus, D references a copy of H, and is given a copy of the
>>>>>>>>>>>>>>> finite string representation of itself. Thus no
>>>>>>>>>>>>>>> "recursion of
>>>>>>>>>>>>>>> references" in the definition of the program or the input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The program D makes a simple copy of its input, which is a
>>>>>>>>>>>>>>> finite operation and then goes into its copy of the
>>>>>>>>>>>>>>> program H.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Program H, to be a decider, must return an answer in a
>>>>>>>>>>>>>>> finite
>>>>>>>>>>>>>>> amount of time.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> A valid SHD with sufficient resources will return an
>>>>>>>>>>>>>> answer in
>>>>>>>>>>>>>> a finite amount of time.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Then so will D (unless the answer H gives is Halting, then for
>>>>>>>>>>>>> the Linz "D", D will just loop to show H wrong. For Sipser, D
>>>>>>>>>>>>> will just return 0 to make H wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You can't argue that D doesn't return due to an infinite
>>>>>>>>>>>>> recursion, but H does, as the only recursion possible is
>>>>>>>>>>>>> mutual.
>>>>>>>>>>>>
>>>>>>>>>>>> Nope. H isn't D. If D references H in such a way that infinite
>>>>>>>>>>>> recursion would result (i.e. D is pathological) then D is not a
>>>>>>>>>>>> program. Note: *ONLY* the Flibble Signaling Simulating Halt
>>>>>>>>>>>> Decider can handle this situation properly.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Program H doesn't "reference" the input, it was just
>>>>>>>>>>>>>>> provided
>>>>>>>>>>>>>>> as its input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Program H doesn't "call" D, it decides based on the
>>>>>>>>>>>>>>> representation of D.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If H gets its self stuck in the loop you described, that
>>>>>>>>>>>>>>> just
>>>>>>>>>>>>>>> means that H faisl to meet its requirements. This is a known
>>>>>>>>>>>>>>> issue with trying to halt decide by just emulation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nope. It only gets "stuck in the loop" if the input is "an
>>>>>>>>>>>>>> impossible program" as per [Strachey 1965] i.e. invalid input
>>>>>>>>>>>>>> which necessitates a halting decision of "not a program";
>>>>>>>>>>>>>> it is
>>>>>>>>>>>>>> valid to "abort" the simulation when such a "loop" is
>>>>>>>>>>>>>> detected
>>>>>>>>>>>>>> (where I agree with Olcott) and return a halting decision of
>>>>>>>>>>>>>> "not a program" (where I disagree with Olcott).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>
>>>>>>>>>>>>> And the "impossible program" is a valid program, so you are
>>>>>>>>>>>>> just
>>>>>>>>>>>>> admitting that you H can't answer for all valid programs.
>>>>>>>>>>>>
>>>>>>>>>>>> LOL. Of course the impossible program is not a valid
>>>>>>>>>>>> program: you
>>>>>>>>>>>> seem to lack an understanding of simple English words.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Validity of a program is a SYNTAX decision, and D IS a valid
>>>>>>>>>>>>> program if H is.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I guess you just don't understand what a program is.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Note, YOUR definition leads to the contradiction that D IS a
>>>>>>>>>>>>> valid program if given to a DIFFERENT version of the decider,
>>>>>>>>>>>>> but isn't if given to this version.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The validity of a program, as to BEING a program, is a
>>>>>>>>>>>>> universal
>>>>>>>>>>>>> truth.
>>>>>>>>>>>>>
>>>>>>>>>>>>> All you are proving is that your H can't accept *ALL*
>>>>>>>>>>>>> Programs,
>>>>>>>>>>>>> as requried by the problem definition.
>>>>>>>>>>>>
>>>>>>>>>>>> Nope. The Flibble Signaling Simulating Halt Decider can accept
>>>>>>>>>>>> *ALL* valid programs and *ALL* invalid programs and is
>>>>>>>>>>>> capable of
>>>>>>>>>>>> distinguishing between the two types.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Nope, D uses a copy of H, modifying according to acceptable
>>>>>>>>>>> program modifications so D WILL be a program if H is,
>>>>>>>>>>>
>>>>>>>>>>> Note "Valid" for programs means is a set of instructions that
>>>>>>>>>>> produces a definitive results. Since H needs to do that, so will
>>>>>>>>>>> D, and thus D IS "Valid".
>>>>>>>>>>>
>>>>>>>>>>> The only "Qualification" the decider gets to use for "valid"
>>>>>>>>>>> is if
>>>>>>>>>>> it actually represents an actual program.
>>>>>>>>>>>
>>>>>>>>>>> Some "Descriptions" that it can be given might not meet the
>>>>>>>>>>> syntax
>>>>>>>>>>> requriements to be a program. Those could be rejected as "Not A
>>>>>>>>>>> Program", but D doesn't fall into that category.
>>>>>>>>>>
>>>>>>>>>> Syntax requirements?! LOLWUT! You clearly have no clue about what
>>>>>>>>>> you are talking about. This has nothing to do with "syntax"
>>>>>>>>>> whatsoever you twit.
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>> Nope, shows YOU don't know what you are talking about.
>>>>>>>>>
>>>>>>>>> The only thing that makes an input not a valid program is if it
>>>>>>>>> fails the SYNTAX check.
>>>>>>>>>
>>>>>>>>> There are no "Semantics" that define what is a valid program, only
>>>>>>>>> syntactic criteria.
>>>>>>>>>
>>>>>>>>> What the execution of the program does is Semantics, that it
>>>>>>>>> CAN be
>>>>>>>>> executed is syntax.
>>>>>>>>
>>>>>>>> You have no clue! Nobody is denying that a program that can't be
>>>>>>>> compiled due to a syntax error is invalid; in this case however the
>>>>>>>> program is invalid for a different reason: the infinitely recursive
>>>>>>>> relationship between the program and the halt decider, a
>>>>>>>> category error.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>
>>>>>>> Nope, a program that goes into an infinite loop is a perfectly fine
>>>>>>> program.
>>>>>>>
>>>>>>> There is nothing "invalid" about the design of the program D, it
>>>>>>> just
>>>>>>> makes it impossible for H to give the right answer.
>>>>>>>
>>>>>>> Please point out where in the definition of a "Program" there is any
>>>>>>> grounds to call "D" as not valid?
>>>>>>>
>>>>>>> You are just proving that you aren't a "Troll", but an "Idiot".
>>>>>>
>>>>>> You have no clue! You are such a beginner!
>>>>>>
>>>>>> First off infinite recursion and infinite loop are two different
>>>>>> things.
>>>>>>
>>>>>> Secondly the infinite recursion only manifests when the halt
>>>>>> decider is
>>>>>> of the simulating type; if the halt decider is of the non-simulating
>>>>>> type there is no infinite recursion as it isn't possible to even
>>>>>> build
>>>>>> the program in the first place as the program cannot even exist
>>>>>> due to
>>>>>> infinite self reference in the problem definition, a category error.
>>>>>>
>>>>>> Who is more idiotic? The idiot or the idiot that argues with the
>>>>>> idiot?
>>>>>>
>>>>>> /Flibble
>>>>> Right, which just makes the Simulating Halt Decider an incorect Halt
>>>>> Decidder, not the input somehow "invalid".
>>>>>
>>>>> And, there is NO problem building the program D, (except that it is
>>>>> impossible to have a correct H, just like for the same reason there is
>>>>> no correct Simulating Halt Decider).
>>>>>
>>>>> Any H that you build that CLAIMS to be a Halt Decider, clearly allows
>>>>> you to build a program D, and a representation for that program to
>>>>> give
>>>>> to D or H.
>>>>>
>>>>> There is no "infinite self reference" in the problem definition.
>>>>>
>>>>> An H is defined that claims to be correct.
>>>>>
>>>>> A D is built from it by a simple template.
>>>>>
>>>>> The Input it built by converting that program into a description.
>>>>>
>>>>> Then we can show that H must be incorrect.
>>>>>
>>>>> The exact same can be done with your "Simulating Halt Decider", and
>>>>> there is ZERO grounds to call the input "Invalid" as it was built
>>>>> by the
>>>>> normal construction rules of a program from the program H.
>>>>>
>>>>> The only way that D can't meet the definition of a program is for H to
>>>>> fail to meet the definition.
>>>>>
>>>>>
>>>>> As to why answer:
>>>>>
>>>>> Answer a fool according to his folly,
>>>>> or he will be wise in his own eyes.
>>>> "I seem to remember formal logicians disrespect this 'riddle' to a
>>>> man or woman."
>>> It's taken as being criterial for your being an illogical
>>> bullshitter, etc.
>>
>> "If you think the Halting Problem is ill-posed, or was not definitely
>> solved by Alan Turing... this might not be the newsgroup for you."
>
> The a herd of sheep cannot understand me because this herd stays stuck
> on the groupthink error does not entail that I am incorrect.
>
> When a decision problem is defined as what yes/no answer can Bill say
> that correctly predicts the answer that Harry will provide when Harry
> makes sure to always provide the opposite of whatever Bill predicts.
> This "decision problem" is equivalent to Russell's Barber Paradox.
>
> *The diagonal argument of the halting theorem has this exact same form*
>
> Russell's Paradox was abolished by correcting the mistakes of naive set
> theory and establishing ZFC set theory as its basis.
>
> In other words a barber that says he shaves all those that do not shave
> themselves was ultimately determined to simply be a liar.
>
> https://en.wikipedia.org/wiki/Barber_paradox
>
> https://en.wikipedia.org/wiki/Russell%27s_paradox
>
> A simulating halt decider overcomes the pathology of the halting
> problem proofs.

On 3/18/2023 10:19 AM, Jeffrey Rubard wrote:
> On Tuesday, March 14, 2023 at 2:09:26 PM UTC-7, Jeffrey Rubard wrote:
>> On Tuesday, March 14, 2023 at 2:08:44 PM UTC-7, Jeffrey Rubard wrote:
>>> On Saturday, March 11, 2023 at 2:11:46 PM UTC-8, Richard Damon wrote:
>>>> On 3/11/23 4:14 PM, Mr Flibble wrote:
>>>>> On 11/03/2023 20:28, Richard Damon wrote:
>>>>>> On 3/11/23 2:51 PM, Mr Flibble wrote:
>>>>>>> On 11/03/2023 18:28, Richard Damon wrote:
>>>>>>>> On 3/11/23 12:35 PM, Mr Flibble wrote:
>>>>>>>>> On 11/03/2023 16:52, Richard Damon wrote:
>>>>>>>>>> On 3/11/23 9:53 AM, Mr Flibble wrote:
>>>>>>>>>>> On 11/03/2023 14:36, Richard Damon wrote:
>>>>>>>>>>>> On 3/11/23 9:26 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On 11/03/2023 11:58, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/11/23 6:20 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On 11/03/2023 01:06, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/10/23 7:17 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On 10/03/2023 23:38, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/10/23 6:26 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> On 10/03/2023 22:38, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/10/2023 4:17 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>> On 10/03/2023 21:45, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 6/6/2004 9:11 AM, Olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> One very simple transformation of the problem into a
>>>>>>>>>>>>>>>>>>>>>>> solvable problem
>>>>>>>>>>>>>>>>>>>>>>> is to convert the Boolean function DoesItHalt() into
>>>>>>>>>>>>>>>>>>>>>>> a tertiary response:
>>>>>>>>>>>>>>>>>>>>>>> True, False, Neither.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> if (DoesItHalt() == True)
>>>>>>>>>>>>>>>>>>>>>>> while(True) // loop forever
>>>>>>>>>>>>>>>>>>>>>>> ;
>>>>>>>>>>>>>>>>>>>>>>> else if (DoesItHalt() == False)
>>>>>>>>>>>>>>>>>>>>>>> return False;
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> else if (DoesItHalt() == NeitherTrueNorFalse)
>>>>>>>>>>>>>>>>>>>>>>> return NeitherTrueNorFalse;
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> So the original Halting Problem was incorrectly
>>>>>>>>>>>>>>>>>>>>>>> formed specifically
>>>>>>>>>>>>>>>>>>>>>>> because it was framed as a Boolean function, thus
>>>>>>>>>>>>>>>>>>>>>>> failing to account
>>>>>>>>>>>>>>>>>>>>>>> for possible inputs that result in a reply other than
>>>>>>>>>>>>>>>>>>>>>>> True or False.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Message-ID:
>>>>>>>>>>>>>>>>>>>>>> <bCFwc.13980$Gx4....@bgtnsc04-news.ops.worldnet.att.net>
>>>>>>>>>>>>>>>>>>>>>> [Alan Turing's Halting Problem is incorrectly formed]
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> This is my very first USENET post about the Halting
>>>>>>>>>>>>>>>>>>>>>> Problem
>>>>>>>>>>>>>>>>>>>>>> back On 6/6/2004 9:11 AM
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> And yet you have reversed your position and instead of
>>>>>>>>>>>>>>>>>>>>> creating a decider with a ternary result you have gone
>>>>>>>>>>>>>>>>>>>>> back to returning a binary result. This was your fatal
>>>>>>>>>>>>>>>>>>>>> mistake, a mistake you probably made due to you naively
>>>>>>>>>>>>>>>>>>>>> being convinced by the received (but erroneous) wisdom
>>>>>>>>>>>>>>>>>>>>> of others.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> 01 int D(int (*x)())
>>>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>>>> 03 int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>> 04 if (Halt_Status)
>>>>>>>>>>>>>>>>>>>> 05 HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>> 06 return Halt_Status;
>>>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Since D correctly simulated by H cannot possibly reach
>>>>>>>>>>>>>>>>>>>> its own final
>>>>>>>>>>>>>>>>>>>> state "return" instruction in any finite number is
>>>>>>>>>>>>>>>>>>>> simulated steps H is
>>>>>>>>>>>>>>>>>>>> necessarily correct to reject its input D as non-halting.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *The simulated D cannot possibly get past its own line 03*
>>>>>>>>>>>>>>>>>>>> H(D,D) simulates D(D) that calls H(D,D) to simulate
>>>>>>>>>>>>>>>>>>>> itself again...
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> An invalid program neither halts nor doesn't halt.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So D can't be an invalid program as it will always either
>>>>>>>>>>>>>>>>>> Halt or Not depending on the definiton of H. The only way
>>>>>>>>>>>>>>>>>> for D to not be a valid program is if H isn't a valid
>>>>>>>>>>>>>>>>>> program, and then H can't be a correct halt decider.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> WRONG. The reason is subtle. It isn't that D is invalid,
>>>>>>>>>>>>>>>>> or that H isn't a correct halt decider, what is invalid is
>>>>>>>>>>>>>>>>> the COMBINATION of D and H. The combination is the
>>>>>>>>>>>>>>>>> category error (the Impossible Program of [Strachey 1965]).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Not possible.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Either D is or is not a program.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If it is, then ALL Halt decider need to be able to decide
>>>>>>>>>>>>>>>> it, even H.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That comes from the meaning of **ALL**
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> D is not a program as it references H which references D
>>>>>>>>>>>>>>> which references H .. ad infinitum. This recursion is a
>>>>>>>>>>>>>>> manifestation of the category error present in the problem
>>>>>>>>>>>>>>> definition and is only present if the halt decider is of the
>>>>>>>>>>>>>>> simulating type (only SHDs can detect and report on the
>>>>>>>>>>>>>>> pathology via a third result); so:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> 1) Only SHDs can solve the halting problem;
>>>>>>>>>>>>>>> 2) SHDs must have a ternary result as invalid programs
>>>>>>>>>>>>>>> neither halt nor don't halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This unique insight is attributable to Mr Flibble who is the
>>>>>>>>>>>>>>> only person to have solved the halting problem.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So, you don;t understand how it is setup at all.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes, D is a program, built off the code of H, which needs to
>>>>>>>>>>>>>> be program to meet the specifications.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> By specifications, program H is considered as a fundamental unit.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> D is given as an input, a finite string representation of this
>>>>>>>>>>>>>> program D. All programs have a finite string repesentation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Thus, D references a copy of H, and is given a copy of the
>>>>>>>>>>>>>> finite string representation of itself. Thus no "recursion of
>>>>>>>>>>>>>> references" in the definition of the program or the input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The program D makes a simple copy of its input, which is a
>>>>>>>>>>>>>> finite operation and then goes into its copy of the program H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Program H, to be a decider, must return an answer in a finite
>>>>>>>>>>>>>> amount of time.
>>>>>>>>>>>>>
>>>>>>>>>>>>> A valid SHD with sufficient resources will return an answer in
>>>>>>>>>>>>> a finite amount of time.
>>>>>>>>>>>>
>>>>>>>>>>>> Then so will D (unless the answer H gives is Halting, then for
>>>>>>>>>>>> the Linz "D", D will just loop to show H wrong. For Sipser, D
>>>>>>>>>>>> will just return 0 to make H wrong.
>>>>>>>>>>>>
>>>>>>>>>>>> You can't argue that D doesn't return due to an infinite
>>>>>>>>>>>> recursion, but H does, as the only recursion possible is mutual.
>>>>>>>>>>>
>>>>>>>>>>> Nope. H isn't D. If D references H in such a way that infinite
>>>>>>>>>>> recursion would result (i.e. D is pathological) then D is not a
>>>>>>>>>>> program. Note: *ONLY* the Flibble Signaling Simulating Halt
>>>>>>>>>>> Decider can handle this situation properly.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Program H doesn't "reference" the input, it was just provided
>>>>>>>>>>>>>> as its input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Program H doesn't "call" D, it decides based on the
>>>>>>>>>>>>>> representation of D.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If H gets its self stuck in the loop you described, that just
>>>>>>>>>>>>>> means that H faisl to meet its requirements. This is a known
>>>>>>>>>>>>>> issue with trying to halt decide by just emulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope. It only gets "stuck in the loop" if the input is "an
>>>>>>>>>>>>> impossible program" as per [Strachey 1965] i.e. invalid input
>>>>>>>>>>>>> which necessitates a halting decision of "not a program"; it is
>>>>>>>>>>>>> valid to "abort" the simulation when such a "loop" is detected
>>>>>>>>>>>>> (where I agree with Olcott) and return a halting decision of
>>>>>>>>>>>>> "not a program" (where I disagree with Olcott).
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>
>>>>>>>>>>>> And the "impossible program" is a valid program, so you are just
>>>>>>>>>>>> admitting that you H can't answer for all valid programs.
>>>>>>>>>>>
>>>>>>>>>>> LOL. Of course the impossible program is not a valid program: you
>>>>>>>>>>> seem to lack an understanding of simple English words.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Validity of a program is a SYNTAX decision, and D IS a valid
>>>>>>>>>>>> program if H is.
>>>>>>>>>>>>
>>>>>>>>>>>> I guess you just don't understand what a program is.
>>>>>>>>>>>>
>>>>>>>>>>>> Note, YOUR definition leads to the contradiction that D IS a
>>>>>>>>>>>> valid program if given to a DIFFERENT version of the decider,
>>>>>>>>>>>> but isn't if given to this version.
>>>>>>>>>>>>
>>>>>>>>>>>> The validity of a program, as to BEING a program, is a universal
>>>>>>>>>>>> truth.
>>>>>>>>>>>>
>>>>>>>>>>>> All you are proving is that your H can't accept *ALL* Programs,
>>>>>>>>>>>> as requried by the problem definition.
>>>>>>>>>>>
>>>>>>>>>>> Nope. The Flibble Signaling Simulating Halt Decider can accept
>>>>>>>>>>> *ALL* valid programs and *ALL* invalid programs and is capable of
>>>>>>>>>>> distinguishing between the two types.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Nope, D uses a copy of H, modifying according to acceptable
>>>>>>>>>> program modifications so D WILL be a program if H is,
>>>>>>>>>>
>>>>>>>>>> Note "Valid" for programs means is a set of instructions that
>>>>>>>>>> produces a definitive results. Since H needs to do that, so will
>>>>>>>>>> D, and thus D IS "Valid".
>>>>>>>>>>
>>>>>>>>>> The only "Qualification" the decider gets to use for "valid" is if
>>>>>>>>>> it actually represents an actual program.
>>>>>>>>>>
>>>>>>>>>> Some "Descriptions" that it can be given might not meet the syntax
>>>>>>>>>> requriements to be a program. Those could be rejected as "Not A
>>>>>>>>>> Program", but D doesn't fall into that category.
>>>>>>>>>
>>>>>>>>> Syntax requirements?! LOLWUT! You clearly have no clue about what
>>>>>>>>> you are talking about. This has nothing to do with "syntax"
>>>>>>>>> whatsoever you twit.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>> Nope, shows YOU don't know what you are talking about.
>>>>>>>>
>>>>>>>> The only thing that makes an input not a valid program is if it
>>>>>>>> fails the SYNTAX check.
>>>>>>>>
>>>>>>>> There are no "Semantics" that define what is a valid program, only
>>>>>>>> syntactic criteria.
>>>>>>>>
>>>>>>>> What the execution of the program does is Semantics, that it CAN be
>>>>>>>> executed is syntax.
>>>>>>>
>>>>>>> You have no clue! Nobody is denying that a program that can't be
>>>>>>> compiled due to a syntax error is invalid; in this case however the
>>>>>>> program is invalid for a different reason: the infinitely recursive
>>>>>>> relationship between the program and the halt decider, a category error.
>>>>>>>
>>>>>>> /Flibble
>>>>>>
>>>>>> Nope, a program that goes into an infinite loop is a perfectly fine
>>>>>> program.
>>>>>>
>>>>>> There is nothing "invalid" about the design of the program D, it just
>>>>>> makes it impossible for H to give the right answer.
>>>>>>
>>>>>> Please point out where in the definition of a "Program" there is any
>>>>>> grounds to call "D" as not valid?
>>>>>>
>>>>>> You are just proving that you aren't a "Troll", but an "Idiot".
>>>>>
>>>>> You have no clue! You are such a beginner!
>>>>>
>>>>> First off infinite recursion and infinite loop are two different things.
>>>>>
>>>>> Secondly the infinite recursion only manifests when the halt decider is
>>>>> of the simulating type; if the halt decider is of the non-simulating
>>>>> type there is no infinite recursion as it isn't possible to even build
>>>>> the program in the first place as the program cannot even exist due to
>>>>> infinite self reference in the problem definition, a category error.
>>>>>
>>>>> Who is more idiotic? The idiot or the idiot that argues with the idiot?
>>>>>
>>>>> /Flibble
>>>> Right, which just makes the Simulating Halt Decider an incorect Halt
>>>> Decidder, not the input somehow "invalid".
>>>>
>>>> And, there is NO problem building the program D, (except that it is
>>>> impossible to have a correct H, just like for the same reason there is
>>>> no correct Simulating Halt Decider).
>>>>
>>>> Any H that you build that CLAIMS to be a Halt Decider, clearly allows
>>>> you to build a program D, and a representation for that program to give
>>>> to D or H.
>>>>
>>>> There is no "infinite self reference" in the problem definition.
>>>>
>>>> An H is defined that claims to be correct.
>>>>
>>>> A D is built from it by a simple template.
>>>>
>>>> The Input it built by converting that program into a description.
>>>>
>>>> Then we can show that H must be incorrect.
>>>>
>>>> The exact same can be done with your "Simulating Halt Decider", and
>>>> there is ZERO grounds to call the input "Invalid" as it was built by the
>>>> normal construction rules of a program from the program H.
>>>>
>>>> The only way that D can't meet the definition of a program is for H to
>>>> fail to meet the definition.
>>>>
>>>>
>>>> As to why answer:
>>>>
>>>> Answer a fool according to his folly,
>>>> or he will be wise in his own eyes.
>>> "I seem to remember formal logicians disrespect this 'riddle' to a man or woman."
>> It's taken as being criterial for your being an illogical bullshitter, etc.
>
> "If you think the Halting Problem is ill-posed, or was not definitely solved by Alan Turing... this might not be the newsgroup for you."

On 3/18/2023 11:39 AM, Mr Flibble wrote:
> On 18/03/2023 15:39, olcott wrote:
>> On 3/18/2023 10:19 AM, Jeffrey Rubard wrote:
>>> On Tuesday, March 14, 2023 at 2:09:26 PM UTC-7, Jeffrey Rubard wrote:
>>>> On Tuesday, March 14, 2023 at 2:08:44 PM UTC-7, Jeffrey Rubard wrote:
>>>>> On Saturday, March 11, 2023 at 2:11:46 PM UTC-8, Richard Damon wrote:
>>>>>> On 3/11/23 4:14 PM, Mr Flibble wrote:
>>>>>>> On 11/03/2023 20:28, Richard Damon wrote:
>>>>>>>> On 3/11/23 2:51 PM, Mr Flibble wrote:
>>>>>>>>> On 11/03/2023 18:28, Richard Damon wrote:
>>>>>>>>>> On 3/11/23 12:35 PM, Mr Flibble wrote:
>>>>>>>>>>> On 11/03/2023 16:52, Richard Damon wrote:
>>>>>>>>>>>> On 3/11/23 9:53 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On 11/03/2023 14:36, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/11/23 9:26 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On 11/03/2023 11:58, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/11/23 6:20 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On 11/03/2023 01:06, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/10/23 7:17 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> On 10/03/2023 23:38, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/10/23 6:26 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>> On 10/03/2023 22:38, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/10/2023 4:17 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 10/03/2023 21:45, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 6/6/2004 9:11 AM, Olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> One very simple transformation of the problem
>>>>>>>>>>>>>>>>>>>>>>>>> into a
>>>>>>>>>>>>>>>>>>>>>>>>> solvable problem
>>>>>>>>>>>>>>>>>>>>>>>>> is to convert the Boolean function DoesItHalt()
>>>>>>>>>>>>>>>>>>>>>>>>> into
>>>>>>>>>>>>>>>>>>>>>>>>> a tertiary response:
>>>>>>>>>>>>>>>>>>>>>>>>> True, False, Neither.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> if (DoesItHalt() == True)
>>>>>>>>>>>>>>>>>>>>>>>>> while(True) // loop forever
>>>>>>>>>>>>>>>>>>>>>>>>> ;
>>>>>>>>>>>>>>>>>>>>>>>>> else if (DoesItHalt() == False)
>>>>>>>>>>>>>>>>>>>>>>>>> return False;
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> else if (DoesItHalt() == NeitherTrueNorFalse)
>>>>>>>>>>>>>>>>>>>>>>>>> return NeitherTrueNorFalse;
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> So the original Halting Problem was incorrectly
>>>>>>>>>>>>>>>>>>>>>>>>> formed specifically
>>>>>>>>>>>>>>>>>>>>>>>>> because it was framed as a Boolean function, thus
>>>>>>>>>>>>>>>>>>>>>>>>> failing to account
>>>>>>>>>>>>>>>>>>>>>>>>> for possible inputs that result in a reply
>>>>>>>>>>>>>>>>>>>>>>>>> other than
>>>>>>>>>>>>>>>>>>>>>>>>> True or False.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Message-ID:
>>>>>>>>>>>>>>>>>>>>>>>> <bCFwc.13980$Gx4....@bgtnsc04-news.ops.worldnet.att.net>
>>>>>>>>>>>>>>>>>>>>>>>> [Alan Turing's Halting Problem is incorrectly
>>>>>>>>>>>>>>>>>>>>>>>> formed]
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> This is my very first USENET post about the Halting
>>>>>>>>>>>>>>>>>>>>>>>> Problem
>>>>>>>>>>>>>>>>>>>>>>>> back On 6/6/2004 9:11 AM
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> And yet you have reversed your position and
>>>>>>>>>>>>>>>>>>>>>>> instead of
>>>>>>>>>>>>>>>>>>>>>>> creating a decider with a ternary result you have
>>>>>>>>>>>>>>>>>>>>>>> gone
>>>>>>>>>>>>>>>>>>>>>>> back to returning a binary result. This was your
>>>>>>>>>>>>>>>>>>>>>>> fatal
>>>>>>>>>>>>>>>>>>>>>>> mistake, a mistake you probably made due to you
>>>>>>>>>>>>>>>>>>>>>>> naively
>>>>>>>>>>>>>>>>>>>>>>> being convinced by the received (but erroneous)
>>>>>>>>>>>>>>>>>>>>>>> wisdom
>>>>>>>>>>>>>>>>>>>>>>> of others.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> 01 int D(int (*x)())
>>>>>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>>>>>> 03 int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>> 04 if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>> 05 HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>> 06 return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Since D correctly simulated by H cannot possibly
>>>>>>>>>>>>>>>>>>>>>> reach
>>>>>>>>>>>>>>>>>>>>>> its own final
>>>>>>>>>>>>>>>>>>>>>> state "return" instruction in any finite number is
>>>>>>>>>>>>>>>>>>>>>> simulated steps H is
>>>>>>>>>>>>>>>>>>>>>> necessarily correct to reject its input D as
>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *The simulated D cannot possibly get past its own
>>>>>>>>>>>>>>>>>>>>>> line 03*
>>>>>>>>>>>>>>>>>>>>>> H(D,D) simulates D(D) that calls H(D,D) to simulate
>>>>>>>>>>>>>>>>>>>>>> itself again...
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> An invalid program neither halts nor doesn't halt.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> So D can't be an invalid program as it will always
>>>>>>>>>>>>>>>>>>>> either
>>>>>>>>>>>>>>>>>>>> Halt or Not depending on the definiton of H. The
>>>>>>>>>>>>>>>>>>>> only way
>>>>>>>>>>>>>>>>>>>> for D to not be a valid program is if H isn't a valid
>>>>>>>>>>>>>>>>>>>> program, and then H can't be a correct halt decider.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> WRONG. The reason is subtle. It isn't that D is invalid,
>>>>>>>>>>>>>>>>>>> or that H isn't a correct halt decider, what is
>>>>>>>>>>>>>>>>>>> invalid is
>>>>>>>>>>>>>>>>>>> the COMBINATION of D and H. The combination is the
>>>>>>>>>>>>>>>>>>> category error (the Impossible Program of [Strachey
>>>>>>>>>>>>>>>>>>> 1965]).
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Not possible.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Either D is or is not a program.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If it is, then ALL Halt decider need to be able to decide
>>>>>>>>>>>>>>>>>> it, even H.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> That comes from the meaning of **ALL**
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> D is not a program as it references H which references D
>>>>>>>>>>>>>>>>> which references H .. ad infinitum. This recursion is a
>>>>>>>>>>>>>>>>> manifestation of the category error present in the problem
>>>>>>>>>>>>>>>>> definition and is only present if the halt decider is
>>>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>>>> simulating type (only SHDs can detect and report on the
>>>>>>>>>>>>>>>>> pathology via a third result); so:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> 1) Only SHDs can solve the halting problem;
>>>>>>>>>>>>>>>>> 2) SHDs must have a ternary result as invalid programs
>>>>>>>>>>>>>>>>> neither halt nor don't halt.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> This unique insight is attributable to Mr Flibble who
>>>>>>>>>>>>>>>>> is the
>>>>>>>>>>>>>>>>> only person to have solved the halting problem.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So, you don;t understand how it is setup at all.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Yes, D is a program, built off the code of H, which
>>>>>>>>>>>>>>>> needs to
>>>>>>>>>>>>>>>> be program to meet the specifications.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> By specifications, program H is considered as a
>>>>>>>>>>>>>>>> fundamental unit.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> D is given as an input, a finite string representation
>>>>>>>>>>>>>>>> of this
>>>>>>>>>>>>>>>> program D. All programs have a finite string repesentation.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Thus, D references a copy of H, and is given a copy of the
>>>>>>>>>>>>>>>> finite string representation of itself. Thus no
>>>>>>>>>>>>>>>> "recursion of
>>>>>>>>>>>>>>>> references" in the definition of the program or the input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The program D makes a simple copy of its input, which is a
>>>>>>>>>>>>>>>> finite operation and then goes into its copy of the
>>>>>>>>>>>>>>>> program H.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Program H, to be a decider, must return an answer in a
>>>>>>>>>>>>>>>> finite
>>>>>>>>>>>>>>>> amount of time.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A valid SHD with sufficient resources will return an
>>>>>>>>>>>>>>> answer in
>>>>>>>>>>>>>>> a finite amount of time.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Then so will D (unless the answer H gives is Halting, then
>>>>>>>>>>>>>> for
>>>>>>>>>>>>>> the Linz "D", D will just loop to show H wrong. For Sipser, D
>>>>>>>>>>>>>> will just return 0 to make H wrong.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You can't argue that D doesn't return due to an infinite
>>>>>>>>>>>>>> recursion, but H does, as the only recursion possible is
>>>>>>>>>>>>>> mutual.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope. H isn't D. If D references H in such a way that infinite
>>>>>>>>>>>>> recursion would result (i.e. D is pathological) then D is
>>>>>>>>>>>>> not a
>>>>>>>>>>>>> program. Note: *ONLY* the Flibble Signaling Simulating Halt
>>>>>>>>>>>>> Decider can handle this situation properly.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Program H doesn't "reference" the input, it was just
>>>>>>>>>>>>>>>> provided
>>>>>>>>>>>>>>>> as its input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Program H doesn't "call" D, it decides based on the
>>>>>>>>>>>>>>>> representation of D.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If H gets its self stuck in the loop you described, that
>>>>>>>>>>>>>>>> just
>>>>>>>>>>>>>>>> means that H faisl to meet its requirements. This is a
>>>>>>>>>>>>>>>> known
>>>>>>>>>>>>>>>> issue with trying to halt decide by just emulation.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Nope. It only gets "stuck in the loop" if the input is "an
>>>>>>>>>>>>>>> impossible program" as per [Strachey 1965] i.e. invalid
>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>> which necessitates a halting decision of "not a program";
>>>>>>>>>>>>>>> it is
>>>>>>>>>>>>>>> valid to "abort" the simulation when such a "loop" is
>>>>>>>>>>>>>>> detected
>>>>>>>>>>>>>>> (where I agree with Olcott) and return a halting decision of
>>>>>>>>>>>>>>> "not a program" (where I disagree with Olcott).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And the "impossible program" is a valid program, so you
>>>>>>>>>>>>>> are just
>>>>>>>>>>>>>> admitting that you H can't answer for all valid programs.
>>>>>>>>>>>>>
>>>>>>>>>>>>> LOL. Of course the impossible program is not a valid
>>>>>>>>>>>>> program: you
>>>>>>>>>>>>> seem to lack an understanding of simple English words.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Validity of a program is a SYNTAX decision, and D IS a valid
>>>>>>>>>>>>>> program if H is.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I guess you just don't understand what a program is.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Note, YOUR definition leads to the contradiction that D IS a
>>>>>>>>>>>>>> valid program if given to a DIFFERENT version of the decider,
>>>>>>>>>>>>>> but isn't if given to this version.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The validity of a program, as to BEING a program, is a
>>>>>>>>>>>>>> universal
>>>>>>>>>>>>>> truth.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> All you are proving is that your H can't accept *ALL*
>>>>>>>>>>>>>> Programs,
>>>>>>>>>>>>>> as requried by the problem definition.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope. The Flibble Signaling Simulating Halt Decider can accept
>>>>>>>>>>>>> *ALL* valid programs and *ALL* invalid programs and is
>>>>>>>>>>>>> capable of
>>>>>>>>>>>>> distinguishing between the two types.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, D uses a copy of H, modifying according to acceptable
>>>>>>>>>>>> program modifications so D WILL be a program if H is,
>>>>>>>>>>>>
>>>>>>>>>>>> Note "Valid" for programs means is a set of instructions that
>>>>>>>>>>>> produces a definitive results. Since H needs to do that, so
>>>>>>>>>>>> will
>>>>>>>>>>>> D, and thus D IS "Valid".
>>>>>>>>>>>>
>>>>>>>>>>>> The only "Qualification" the decider gets to use for "valid"
>>>>>>>>>>>> is if
>>>>>>>>>>>> it actually represents an actual program.
>>>>>>>>>>>>
>>>>>>>>>>>> Some "Descriptions" that it can be given might not meet the
>>>>>>>>>>>> syntax
>>>>>>>>>>>> requriements to be a program. Those could be rejected as "Not A
>>>>>>>>>>>> Program", but D doesn't fall into that category.
>>>>>>>>>>>
>>>>>>>>>>> Syntax requirements?! LOLWUT! You clearly have no clue about
>>>>>>>>>>> what
>>>>>>>>>>> you are talking about. This has nothing to do with "syntax"
>>>>>>>>>>> whatsoever you twit.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>> Nope, shows YOU don't know what you are talking about.
>>>>>>>>>>
>>>>>>>>>> The only thing that makes an input not a valid program is if it
>>>>>>>>>> fails the SYNTAX check.
>>>>>>>>>>
>>>>>>>>>> There are no "Semantics" that define what is a valid program,
>>>>>>>>>> only
>>>>>>>>>> syntactic criteria.
>>>>>>>>>>
>>>>>>>>>> What the execution of the program does is Semantics, that it
>>>>>>>>>> CAN be
>>>>>>>>>> executed is syntax.
>>>>>>>>>
>>>>>>>>> You have no clue! Nobody is denying that a program that can't be
>>>>>>>>> compiled due to a syntax error is invalid; in this case however
>>>>>>>>> the
>>>>>>>>> program is invalid for a different reason: the infinitely
>>>>>>>>> recursive
>>>>>>>>> relationship between the program and the halt decider, a
>>>>>>>>> category error.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>> Nope, a program that goes into an infinite loop is a perfectly fine
>>>>>>>> program.
>>>>>>>>
>>>>>>>> There is nothing "invalid" about the design of the program D, it
>>>>>>>> just
>>>>>>>> makes it impossible for H to give the right answer.
>>>>>>>>
>>>>>>>> Please point out where in the definition of a "Program" there is
>>>>>>>> any
>>>>>>>> grounds to call "D" as not valid?
>>>>>>>>
>>>>>>>> You are just proving that you aren't a "Troll", but an "Idiot".
>>>>>>>
>>>>>>> You have no clue! You are such a beginner!
>>>>>>>
>>>>>>> First off infinite recursion and infinite loop are two different
>>>>>>> things.
>>>>>>>
>>>>>>> Secondly the infinite recursion only manifests when the halt
>>>>>>> decider is
>>>>>>> of the simulating type; if the halt decider is of the non-simulating
>>>>>>> type there is no infinite recursion as it isn't possible to even
>>>>>>> build
>>>>>>> the program in the first place as the program cannot even exist
>>>>>>> due to
>>>>>>> infinite self reference in the problem definition, a category error.
>>>>>>>
>>>>>>> Who is more idiotic? The idiot or the idiot that argues with the
>>>>>>> idiot?
>>>>>>>
>>>>>>> /Flibble
>>>>>> Right, which just makes the Simulating Halt Decider an incorect Halt
>>>>>> Decidder, not the input somehow "invalid".
>>>>>>
>>>>>> And, there is NO problem building the program D, (except that it is
>>>>>> impossible to have a correct H, just like for the same reason
>>>>>> there is
>>>>>> no correct Simulating Halt Decider).
>>>>>>
>>>>>> Any H that you build that CLAIMS to be a Halt Decider, clearly allows
>>>>>> you to build a program D, and a representation for that program to
>>>>>> give
>>>>>> to D or H.
>>>>>>
>>>>>> There is no "infinite self reference" in the problem definition.
>>>>>>
>>>>>> An H is defined that claims to be correct.
>>>>>>
>>>>>> A D is built from it by a simple template.
>>>>>>
>>>>>> The Input it built by converting that program into a description.
>>>>>>
>>>>>> Then we can show that H must be incorrect.
>>>>>>
>>>>>> The exact same can be done with your "Simulating Halt Decider", and
>>>>>> there is ZERO grounds to call the input "Invalid" as it was built
>>>>>> by the
>>>>>> normal construction rules of a program from the program H.
>>>>>>
>>>>>> The only way that D can't meet the definition of a program is for
>>>>>> H to
>>>>>> fail to meet the definition.
>>>>>>
>>>>>>
>>>>>> As to why answer:
>>>>>>
>>>>>> Answer a fool according to his folly,
>>>>>> or he will be wise in his own eyes.
>>>>> "I seem to remember formal logicians disrespect this 'riddle' to a
>>>>> man or woman."
>>>> It's taken as being criterial for your being an illogical
>>>> bullshitter, etc.
>>>
>>> "If you think the Halting Problem is ill-posed, or was not definitely
>>> solved by Alan Turing... this might not be the newsgroup for you."
>>
>> The a herd of sheep cannot understand me because this herd stays stuck
>> on the groupthink error does not entail that I am incorrect.
>>
>> When a decision problem is defined as what yes/no answer can Bill say
>> that correctly predicts the answer that Harry will provide when Harry
>> makes sure to always provide the opposite of whatever Bill predicts.
>> This "decision problem" is equivalent to Russell's Barber Paradox.
>>
>> *The diagonal argument of the halting theorem has this exact same form*
>>
>> Russell's Paradox was abolished by correcting the mistakes of naive set
>> theory and establishing ZFC set theory as its basis.
>>
>> In other words a barber that says he shaves all those that do not shave
>> themselves was ultimately determined to simply be a liar.
>>
>> https://en.wikipedia.org/wiki/Barber_paradox
>>
>> https://en.wikipedia.org/wiki/Russell%27s_paradox
>>
>> A simulating halt decider overcomes the pathology of the halting
>> problem proofs.
>
> You are just repeating Mr Flibble's original research which is Copyright
> (c) 2022 Mr Flibble.  Your attempt to avoid copyright infringement by
> backtracking on the need for a ternary rather than binary halting result
> is transparent.  The only valid halting decider is the Flibble
> Signalling Simulating Halt Decider which is also Copyright (c) 2022 Mr
> Flibble.
>
> https://github.com/i42output/halting-problem/blob/main/README.txt
>
> /Flibble

On 18/03/2023 16:48, olcott wrote:
> On 3/18/2023 11:39 AM, Mr Flibble wrote:
>> On 18/03/2023 15:39, olcott wrote:
>>> On 3/18/2023 10:19 AM, Jeffrey Rubard wrote:
>>>> On Tuesday, March 14, 2023 at 2:09:26 PM UTC-7, Jeffrey Rubard wrote:
>>>>> On Tuesday, March 14, 2023 at 2:08:44 PM UTC-7, Jeffrey Rubard wrote:
>>>>>> On Saturday, March 11, 2023 at 2:11:46 PM UTC-8, Richard Damon wrote:
>>>>>>> On 3/11/23 4:14 PM, Mr Flibble wrote:
>>>>>>>> On 11/03/2023 20:28, Richard Damon wrote:
>>>>>>>>> On 3/11/23 2:51 PM, Mr Flibble wrote:
>>>>>>>>>> On 11/03/2023 18:28, Richard Damon wrote:
>>>>>>>>>>> On 3/11/23 12:35 PM, Mr Flibble wrote:
>>>>>>>>>>>> On 11/03/2023 16:52, Richard Damon wrote:
>>>>>>>>>>>>> On 3/11/23 9:53 AM, Mr Flibble wrote:
>>>>>>>>>>>>>> On 11/03/2023 14:36, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/11/23 9:26 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>> On 11/03/2023 11:58, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/11/23 6:20 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>> On 11/03/2023 01:06, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/10/23 7:17 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>> On 10/03/2023 23:38, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/10/23 6:26 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>> On 10/03/2023 22:38, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/10/2023 4:17 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 10/03/2023 21:45, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 6/6/2004 9:11 AM, Olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> One very simple transformation of the problem
>>>>>>>>>>>>>>>>>>>>>>>>>> into a
>>>>>>>>>>>>>>>>>>>>>>>>>> solvable problem
>>>>>>>>>>>>>>>>>>>>>>>>>> is to convert the Boolean function
>>>>>>>>>>>>>>>>>>>>>>>>>> DoesItHalt() into
>>>>>>>>>>>>>>>>>>>>>>>>>> a tertiary response:
>>>>>>>>>>>>>>>>>>>>>>>>>> True, False, Neither.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> if (DoesItHalt() == True)
>>>>>>>>>>>>>>>>>>>>>>>>>> while(True) // loop forever
>>>>>>>>>>>>>>>>>>>>>>>>>> ;
>>>>>>>>>>>>>>>>>>>>>>>>>> else if (DoesItHalt() == False)
>>>>>>>>>>>>>>>>>>>>>>>>>> return False;
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> else if (DoesItHalt() == NeitherTrueNorFalse)
>>>>>>>>>>>>>>>>>>>>>>>>>> return NeitherTrueNorFalse;
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> So the original Halting Problem was incorrectly
>>>>>>>>>>>>>>>>>>>>>>>>>> formed specifically
>>>>>>>>>>>>>>>>>>>>>>>>>> because it was framed as a Boolean function, thus
>>>>>>>>>>>>>>>>>>>>>>>>>> failing to account
>>>>>>>>>>>>>>>>>>>>>>>>>> for possible inputs that result in a reply
>>>>>>>>>>>>>>>>>>>>>>>>>> other than
>>>>>>>>>>>>>>>>>>>>>>>>>> True or False.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Message-ID:
>>>>>>>>>>>>>>>>>>>>>>>>> <bCFwc.13980$Gx4....@bgtnsc04-news.ops.worldnet.att.net>
>>>>>>>>>>>>>>>>>>>>>>>>> [Alan Turing's Halting Problem is incorrectly
>>>>>>>>>>>>>>>>>>>>>>>>> formed]
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> This is my very first USENET post about the
>>>>>>>>>>>>>>>>>>>>>>>>> Halting
>>>>>>>>>>>>>>>>>>>>>>>>> Problem
>>>>>>>>>>>>>>>>>>>>>>>>> back On 6/6/2004 9:11 AM
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> And yet you have reversed your position and
>>>>>>>>>>>>>>>>>>>>>>>> instead of
>>>>>>>>>>>>>>>>>>>>>>>> creating a decider with a ternary result you
>>>>>>>>>>>>>>>>>>>>>>>> have gone
>>>>>>>>>>>>>>>>>>>>>>>> back to returning a binary result. This was your
>>>>>>>>>>>>>>>>>>>>>>>> fatal
>>>>>>>>>>>>>>>>>>>>>>>> mistake, a mistake you probably made due to you
>>>>>>>>>>>>>>>>>>>>>>>> naively
>>>>>>>>>>>>>>>>>>>>>>>> being convinced by the received (but erroneous)
>>>>>>>>>>>>>>>>>>>>>>>> wisdom
>>>>>>>>>>>>>>>>>>>>>>>> of others.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> 01 int D(int (*x)())
>>>>>>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>>>>>>> 03 int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>> 04 if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>> 05 HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>> 06 return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Since D correctly simulated by H cannot possibly
>>>>>>>>>>>>>>>>>>>>>>> reach
>>>>>>>>>>>>>>>>>>>>>>> its own final
>>>>>>>>>>>>>>>>>>>>>>> state "return" instruction in any finite number is
>>>>>>>>>>>>>>>>>>>>>>> simulated steps H is
>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to reject its input D as
>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *The simulated D cannot possibly get past its own
>>>>>>>>>>>>>>>>>>>>>>> line 03*
>>>>>>>>>>>>>>>>>>>>>>> H(D,D) simulates D(D) that calls H(D,D) to simulate
>>>>>>>>>>>>>>>>>>>>>>> itself again...
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> An invalid program neither halts nor doesn't halt.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So D can't be an invalid program as it will always
>>>>>>>>>>>>>>>>>>>>> either
>>>>>>>>>>>>>>>>>>>>> Halt or Not depending on the definiton of H. The
>>>>>>>>>>>>>>>>>>>>> only way
>>>>>>>>>>>>>>>>>>>>> for D to not be a valid program is if H isn't a valid
>>>>>>>>>>>>>>>>>>>>> program, and then H can't be a correct halt decider.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> WRONG. The reason is subtle. It isn't that D is
>>>>>>>>>>>>>>>>>>>> invalid,
>>>>>>>>>>>>>>>>>>>> or that H isn't a correct halt decider, what is
>>>>>>>>>>>>>>>>>>>> invalid is
>>>>>>>>>>>>>>>>>>>> the COMBINATION of D and H. The combination is the
>>>>>>>>>>>>>>>>>>>> category error (the Impossible Program of [Strachey
>>>>>>>>>>>>>>>>>>>> 1965]).
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Not possible.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Either D is or is not a program.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If it is, then ALL Halt decider need to be able to
>>>>>>>>>>>>>>>>>>> decide
>>>>>>>>>>>>>>>>>>> it, even H.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> That comes from the meaning of **ALL**
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> D is not a program as it references H which references D
>>>>>>>>>>>>>>>>>> which references H .. ad infinitum. This recursion is a
>>>>>>>>>>>>>>>>>> manifestation of the category error present in the
>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>> definition and is only present if the halt decider is
>>>>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>>>>> simulating type (only SHDs can detect and report on the
>>>>>>>>>>>>>>>>>> pathology via a third result); so:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> 1) Only SHDs can solve the halting problem;
>>>>>>>>>>>>>>>>>> 2) SHDs must have a ternary result as invalid programs
>>>>>>>>>>>>>>>>>> neither halt nor don't halt.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This unique insight is attributable to Mr Flibble who
>>>>>>>>>>>>>>>>>> is the
>>>>>>>>>>>>>>>>>> only person to have solved the halting problem.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So, you don;t understand how it is setup at all.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Yes, D is a program, built off the code of H, which
>>>>>>>>>>>>>>>>> needs to
>>>>>>>>>>>>>>>>> be program to meet the specifications.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> By specifications, program H is considered as a
>>>>>>>>>>>>>>>>> fundamental unit.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> D is given as an input, a finite string representation
>>>>>>>>>>>>>>>>> of this
>>>>>>>>>>>>>>>>> program D. All programs have a finite string
>>>>>>>>>>>>>>>>> repesentation.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Thus, D references a copy of H, and is given a copy of the
>>>>>>>>>>>>>>>>> finite string representation of itself. Thus no
>>>>>>>>>>>>>>>>> "recursion of
>>>>>>>>>>>>>>>>> references" in the definition of the program or the input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The program D makes a simple copy of its input, which is a
>>>>>>>>>>>>>>>>> finite operation and then goes into its copy of the
>>>>>>>>>>>>>>>>> program H.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Program H, to be a decider, must return an answer in a
>>>>>>>>>>>>>>>>> finite
>>>>>>>>>>>>>>>>> amount of time.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A valid SHD with sufficient resources will return an
>>>>>>>>>>>>>>>> answer in
>>>>>>>>>>>>>>>> a finite amount of time.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Then so will D (unless the answer H gives is Halting,
>>>>>>>>>>>>>>> then for
>>>>>>>>>>>>>>> the Linz "D", D will just loop to show H wrong. For
>>>>>>>>>>>>>>> Sipser, D
>>>>>>>>>>>>>>> will just return 0 to make H wrong.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You can't argue that D doesn't return due to an infinite
>>>>>>>>>>>>>>> recursion, but H does, as the only recursion possible is
>>>>>>>>>>>>>>> mutual.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nope. H isn't D. If D references H in such a way that
>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>> recursion would result (i.e. D is pathological) then D is
>>>>>>>>>>>>>> not a
>>>>>>>>>>>>>> program. Note: *ONLY* the Flibble Signaling Simulating Halt
>>>>>>>>>>>>>> Decider can handle this situation properly.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Program H doesn't "reference" the input, it was just
>>>>>>>>>>>>>>>>> provided
>>>>>>>>>>>>>>>>> as its input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Program H doesn't "call" D, it decides based on the
>>>>>>>>>>>>>>>>> representation of D.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If H gets its self stuck in the loop you described,
>>>>>>>>>>>>>>>>> that just
>>>>>>>>>>>>>>>>> means that H faisl to meet its requirements. This is a
>>>>>>>>>>>>>>>>> known
>>>>>>>>>>>>>>>>> issue with trying to halt decide by just emulation.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope. It only gets "stuck in the loop" if the input is "an
>>>>>>>>>>>>>>>> impossible program" as per [Strachey 1965] i.e. invalid
>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>> which necessitates a halting decision of "not a
>>>>>>>>>>>>>>>> program"; it is
>>>>>>>>>>>>>>>> valid to "abort" the simulation when such a "loop" is
>>>>>>>>>>>>>>>> detected
>>>>>>>>>>>>>>>> (where I agree with Olcott) and return a halting
>>>>>>>>>>>>>>>> decision of
>>>>>>>>>>>>>>>> "not a program" (where I disagree with Olcott).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And the "impossible program" is a valid program, so you
>>>>>>>>>>>>>>> are just
>>>>>>>>>>>>>>> admitting that you H can't answer for all valid programs.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> LOL. Of course the impossible program is not a valid
>>>>>>>>>>>>>> program: you
>>>>>>>>>>>>>> seem to lack an understanding of simple English words.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Validity of a program is a SYNTAX decision, and D IS a valid
>>>>>>>>>>>>>>> program if H is.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I guess you just don't understand what a program is.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Note, YOUR definition leads to the contradiction that D IS a
>>>>>>>>>>>>>>> valid program if given to a DIFFERENT version of the
>>>>>>>>>>>>>>> decider,
>>>>>>>>>>>>>>> but isn't if given to this version.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The validity of a program, as to BEING a program, is a
>>>>>>>>>>>>>>> universal
>>>>>>>>>>>>>>> truth.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> All you are proving is that your H can't accept *ALL*
>>>>>>>>>>>>>>> Programs,
>>>>>>>>>>>>>>> as requried by the problem definition.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nope. The Flibble Signaling Simulating Halt Decider can
>>>>>>>>>>>>>> accept
>>>>>>>>>>>>>> *ALL* valid programs and *ALL* invalid programs and is
>>>>>>>>>>>>>> capable of
>>>>>>>>>>>>>> distinguishing between the two types.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope, D uses a copy of H, modifying according to acceptable
>>>>>>>>>>>>> program modifications so D WILL be a program if H is,
>>>>>>>>>>>>>
>>>>>>>>>>>>> Note "Valid" for programs means is a set of instructions that
>>>>>>>>>>>>> produces a definitive results. Since H needs to do that, so
>>>>>>>>>>>>> will
>>>>>>>>>>>>> D, and thus D IS "Valid".
>>>>>>>>>>>>>
>>>>>>>>>>>>> The only "Qualification" the decider gets to use for
>>>>>>>>>>>>> "valid" is if
>>>>>>>>>>>>> it actually represents an actual program.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Some "Descriptions" that it can be given might not meet the
>>>>>>>>>>>>> syntax
>>>>>>>>>>>>> requriements to be a program. Those could be rejected as
>>>>>>>>>>>>> "Not A
>>>>>>>>>>>>> Program", but D doesn't fall into that category.
>>>>>>>>>>>>
>>>>>>>>>>>> Syntax requirements?! LOLWUT! You clearly have no clue about
>>>>>>>>>>>> what
>>>>>>>>>>>> you are talking about. This has nothing to do with "syntax"
>>>>>>>>>>>> whatsoever you twit.
>>>>>>>>>>>>
>>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>> Nope, shows YOU don't know what you are talking about.
>>>>>>>>>>>
>>>>>>>>>>> The only thing that makes an input not a valid program is if it
>>>>>>>>>>> fails the SYNTAX check.
>>>>>>>>>>>
>>>>>>>>>>> There are no "Semantics" that define what is a valid program,
>>>>>>>>>>> only
>>>>>>>>>>> syntactic criteria.
>>>>>>>>>>>
>>>>>>>>>>> What the execution of the program does is Semantics, that it
>>>>>>>>>>> CAN be
>>>>>>>>>>> executed is syntax.
>>>>>>>>>>
>>>>>>>>>> You have no clue! Nobody is denying that a program that can't be
>>>>>>>>>> compiled due to a syntax error is invalid; in this case
>>>>>>>>>> however the
>>>>>>>>>> program is invalid for a different reason: the infinitely
>>>>>>>>>> recursive
>>>>>>>>>> relationship between the program and the halt decider, a
>>>>>>>>>> category error.
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>> Nope, a program that goes into an infinite loop is a perfectly
>>>>>>>>> fine
>>>>>>>>> program.
>>>>>>>>>
>>>>>>>>> There is nothing "invalid" about the design of the program D,
>>>>>>>>> it just
>>>>>>>>> makes it impossible for H to give the right answer.
>>>>>>>>>
>>>>>>>>> Please point out where in the definition of a "Program" there
>>>>>>>>> is any
>>>>>>>>> grounds to call "D" as not valid?
>>>>>>>>>
>>>>>>>>> You are just proving that you aren't a "Troll", but an "Idiot".
>>>>>>>>
>>>>>>>> You have no clue! You are such a beginner!
>>>>>>>>
>>>>>>>> First off infinite recursion and infinite loop are two different
>>>>>>>> things.
>>>>>>>>
>>>>>>>> Secondly the infinite recursion only manifests when the halt
>>>>>>>> decider is
>>>>>>>> of the simulating type; if the halt decider is of the
>>>>>>>> non-simulating
>>>>>>>> type there is no infinite recursion as it isn't possible to even
>>>>>>>> build
>>>>>>>> the program in the first place as the program cannot even exist
>>>>>>>> due to
>>>>>>>> infinite self reference in the problem definition, a category
>>>>>>>> error.
>>>>>>>>
>>>>>>>> Who is more idiotic? The idiot or the idiot that argues with the
>>>>>>>> idiot?
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>> Right, which just makes the Simulating Halt Decider an incorect Halt
>>>>>>> Decidder, not the input somehow "invalid".
>>>>>>>
>>>>>>> And, there is NO problem building the program D, (except that it is
>>>>>>> impossible to have a correct H, just like for the same reason
>>>>>>> there is
>>>>>>> no correct Simulating Halt Decider).
>>>>>>>
>>>>>>> Any H that you build that CLAIMS to be a Halt Decider, clearly
>>>>>>> allows
>>>>>>> you to build a program D, and a representation for that program
>>>>>>> to give
>>>>>>> to D or H.
>>>>>>>
>>>>>>> There is no "infinite self reference" in the problem definition.
>>>>>>>
>>>>>>> An H is defined that claims to be correct.
>>>>>>>
>>>>>>> A D is built from it by a simple template.
>>>>>>>
>>>>>>> The Input it built by converting that program into a description.
>>>>>>>
>>>>>>> Then we can show that H must be incorrect.
>>>>>>>
>>>>>>> The exact same can be done with your "Simulating Halt Decider", and
>>>>>>> there is ZERO grounds to call the input "Invalid" as it was built
>>>>>>> by the
>>>>>>> normal construction rules of a program from the program H.
>>>>>>>
>>>>>>> The only way that D can't meet the definition of a program is for
>>>>>>> H to
>>>>>>> fail to meet the definition.
>>>>>>>
>>>>>>>
>>>>>>> As to why answer:
>>>>>>>
>>>>>>> Answer a fool according to his folly,
>>>>>>> or he will be wise in his own eyes.
>>>>>> "I seem to remember formal logicians disrespect this 'riddle' to a
>>>>>> man or woman."
>>>>> It's taken as being criterial for your being an illogical
>>>>> bullshitter, etc.
>>>>
>>>> "If you think the Halting Problem is ill-posed, or was not
>>>> definitely solved by Alan Turing... this might not be the newsgroup
>>>> for you."
>>>
>>> The a herd of sheep cannot understand me because this herd stays
>>> stuck on the groupthink error does not entail that I am incorrect.
>>>
>>> When a decision problem is defined as what yes/no answer can Bill say
>>> that correctly predicts the answer that Harry will provide when Harry
>>> makes sure to always provide the opposite of whatever Bill predicts.
>>> This "decision problem" is equivalent to Russell's Barber Paradox.
>>>
>>> *The diagonal argument of the halting theorem has this exact same form*
>>>
>>> Russell's Paradox was abolished by correcting the mistakes of naive set
>>> theory and establishing ZFC set theory as its basis.
>>>
>>> In other words a barber that says he shaves all those that do not shave
>>> themselves was ultimately determined to simply be a liar.
>>>
>>> https://en.wikipedia.org/wiki/Barber_paradox
>>>
>>> https://en.wikipedia.org/wiki/Russell%27s_paradox
>>>
>>> A simulating halt decider overcomes the pathology of the halting
>>> problem proofs.
>>
>> You are just repeating Mr Flibble's original research which is
>> Copyright (c) 2022 Mr Flibble.  Your attempt to avoid copyright
>> infringement by backtracking on the need for a ternary rather than
>> binary halting result is transparent.  The only valid halting decider
>> is the Flibble Signalling Simulating Halt Decider which is also
>> Copyright (c) 2022 Mr Flibble.
>>
>> https://github.com/i42output/halting-problem/blob/main/README.txt
>>
>> /Flibble
>
> It is very well documented in this forum that I came up with the ternary
> halt decider many years ago back in 2004 in my very first USENET post
> about the halting problem.
>
> on sci.logic before I knew about comp.theory
> On 6/6/2004 9:11 AM, Olcott wrote: sci.logic
> [Alan Turing's Halting Problem is incorrectly formed]
> Message-ID: <bCFwc.13980$Gx4.2537@bgtnsc04-news.ops.worldnet.att.net>
>
> I am sure that I am not the only one that came up with this idea.
>
> The key missing part is writing the actual code that detects and rejects
> the pathological input. Although I have that now it is far less
> important than correctly determining the actual halt status of the
> otherwise "impossible" input.

On 3/18/2023 12:07 PM, Mr Flibble wrote:
> On 18/03/2023 16:48, olcott wrote:
>> On 3/18/2023 11:39 AM, Mr Flibble wrote:
>>> On 18/03/2023 15:39, olcott wrote:
>>>> On 3/18/2023 10:19 AM, Jeffrey Rubard wrote:
>>>>> On Tuesday, March 14, 2023 at 2:09:26 PM UTC-7, Jeffrey Rubard wrote:
>>>>>> On Tuesday, March 14, 2023 at 2:08:44 PM UTC-7, Jeffrey Rubard wrote:
>>>>>>> On Saturday, March 11, 2023 at 2:11:46 PM UTC-8, Richard Damon
>>>>>>> wrote:
>>>>>>>> On 3/11/23 4:14 PM, Mr Flibble wrote:
>>>>>>>>> On 11/03/2023 20:28, Richard Damon wrote:
>>>>>>>>>> On 3/11/23 2:51 PM, Mr Flibble wrote:
>>>>>>>>>>> On 11/03/2023 18:28, Richard Damon wrote:
>>>>>>>>>>>> On 3/11/23 12:35 PM, Mr Flibble wrote:
>>>>>>>>>>>>> On 11/03/2023 16:52, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/11/23 9:53 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On 11/03/2023 14:36, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/11/23 9:26 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On 11/03/2023 11:58, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/11/23 6:20 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> On 11/03/2023 01:06, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/10/23 7:17 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>> On 10/03/2023 23:38, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/10/23 6:26 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 10/03/2023 22:38, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/10/2023 4:17 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 10/03/2023 21:45, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/6/2004 9:11 AM, Olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> One very simple transformation of the problem
>>>>>>>>>>>>>>>>>>>>>>>>>>> into a
>>>>>>>>>>>>>>>>>>>>>>>>>>> solvable problem
>>>>>>>>>>>>>>>>>>>>>>>>>>> is to convert the Boolean function
>>>>>>>>>>>>>>>>>>>>>>>>>>> DoesItHalt() into
>>>>>>>>>>>>>>>>>>>>>>>>>>> a tertiary response:
>>>>>>>>>>>>>>>>>>>>>>>>>>> True, False, Neither.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> if (DoesItHalt() == True)
>>>>>>>>>>>>>>>>>>>>>>>>>>> while(True) // loop forever
>>>>>>>>>>>>>>>>>>>>>>>>>>> ;
>>>>>>>>>>>>>>>>>>>>>>>>>>> else if (DoesItHalt() == False)
>>>>>>>>>>>>>>>>>>>>>>>>>>> return False;
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> else if (DoesItHalt() == NeitherTrueNorFalse)
>>>>>>>>>>>>>>>>>>>>>>>>>>> return NeitherTrueNorFalse;
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> So the original Halting Problem was incorrectly
>>>>>>>>>>>>>>>>>>>>>>>>>>> formed specifically
>>>>>>>>>>>>>>>>>>>>>>>>>>> because it was framed as a Boolean function,
>>>>>>>>>>>>>>>>>>>>>>>>>>> thus
>>>>>>>>>>>>>>>>>>>>>>>>>>> failing to account
>>>>>>>>>>>>>>>>>>>>>>>>>>> for possible inputs that result in a reply
>>>>>>>>>>>>>>>>>>>>>>>>>>> other than
>>>>>>>>>>>>>>>>>>>>>>>>>>> True or False.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Message-ID:
>>>>>>>>>>>>>>>>>>>>>>>>>> <bCFwc.13980$Gx4....@bgtnsc04-news.ops.worldnet.att.net>
>>>>>>>>>>>>>>>>>>>>>>>>>> [Alan Turing's Halting Problem is incorrectly
>>>>>>>>>>>>>>>>>>>>>>>>>> formed]
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> This is my very first USENET post about the
>>>>>>>>>>>>>>>>>>>>>>>>>> Halting
>>>>>>>>>>>>>>>>>>>>>>>>>> Problem
>>>>>>>>>>>>>>>>>>>>>>>>>> back On 6/6/2004 9:11 AM
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> And yet you have reversed your position and
>>>>>>>>>>>>>>>>>>>>>>>>> instead of
>>>>>>>>>>>>>>>>>>>>>>>>> creating a decider with a ternary result you
>>>>>>>>>>>>>>>>>>>>>>>>> have gone
>>>>>>>>>>>>>>>>>>>>>>>>> back to returning a binary result. This was
>>>>>>>>>>>>>>>>>>>>>>>>> your fatal
>>>>>>>>>>>>>>>>>>>>>>>>> mistake, a mistake you probably made due to you
>>>>>>>>>>>>>>>>>>>>>>>>> naively
>>>>>>>>>>>>>>>>>>>>>>>>> being convinced by the received (but erroneous)
>>>>>>>>>>>>>>>>>>>>>>>>> wisdom
>>>>>>>>>>>>>>>>>>>>>>>>> of others.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> 01 int D(int (*x)())
>>>>>>>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>>>>>>>> 03 int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>> 04 if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>> 05 HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>> 06 return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Since D correctly simulated by H cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>> reach
>>>>>>>>>>>>>>>>>>>>>>>> its own final
>>>>>>>>>>>>>>>>>>>>>>>> state "return" instruction in any finite number is
>>>>>>>>>>>>>>>>>>>>>>>> simulated steps H is
>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to reject its input D as
>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *The simulated D cannot possibly get past its
>>>>>>>>>>>>>>>>>>>>>>>> own line 03*
>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) simulates D(D) that calls H(D,D) to simulate
>>>>>>>>>>>>>>>>>>>>>>>> itself again...
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> An invalid program neither halts nor doesn't halt.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> So D can't be an invalid program as it will always
>>>>>>>>>>>>>>>>>>>>>> either
>>>>>>>>>>>>>>>>>>>>>> Halt or Not depending on the definiton of H. The
>>>>>>>>>>>>>>>>>>>>>> only way
>>>>>>>>>>>>>>>>>>>>>> for D to not be a valid program is if H isn't a valid
>>>>>>>>>>>>>>>>>>>>>> program, and then H can't be a correct halt decider.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> WRONG. The reason is subtle. It isn't that D is
>>>>>>>>>>>>>>>>>>>>> invalid,
>>>>>>>>>>>>>>>>>>>>> or that H isn't a correct halt decider, what is
>>>>>>>>>>>>>>>>>>>>> invalid is
>>>>>>>>>>>>>>>>>>>>> the COMBINATION of D and H. The combination is the
>>>>>>>>>>>>>>>>>>>>> category error (the Impossible Program of [Strachey
>>>>>>>>>>>>>>>>>>>>> 1965]).
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Not possible.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Either D is or is not a program.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If it is, then ALL Halt decider need to be able to
>>>>>>>>>>>>>>>>>>>> decide
>>>>>>>>>>>>>>>>>>>> it, even H.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> That comes from the meaning of **ALL**
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> D is not a program as it references H which references D
>>>>>>>>>>>>>>>>>>> which references H .. ad infinitum. This recursion is a
>>>>>>>>>>>>>>>>>>> manifestation of the category error present in the
>>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>>> definition and is only present if the halt decider is
>>>>>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>>>>>> simulating type (only SHDs can detect and report on the
>>>>>>>>>>>>>>>>>>> pathology via a third result); so:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> 1) Only SHDs can solve the halting problem;
>>>>>>>>>>>>>>>>>>> 2) SHDs must have a ternary result as invalid programs
>>>>>>>>>>>>>>>>>>> neither halt nor don't halt.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> This unique insight is attributable to Mr Flibble who
>>>>>>>>>>>>>>>>>>> is the
>>>>>>>>>>>>>>>>>>> only person to have solved the halting problem.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So, you don;t understand how it is setup at all.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Yes, D is a program, built off the code of H, which
>>>>>>>>>>>>>>>>>> needs to
>>>>>>>>>>>>>>>>>> be program to meet the specifications.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> By specifications, program H is considered as a
>>>>>>>>>>>>>>>>>> fundamental unit.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> D is given as an input, a finite string representation
>>>>>>>>>>>>>>>>>> of this
>>>>>>>>>>>>>>>>>> program D. All programs have a finite string
>>>>>>>>>>>>>>>>>> repesentation.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Thus, D references a copy of H, and is given a copy of
>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>> finite string representation of itself. Thus no
>>>>>>>>>>>>>>>>>> "recursion of
>>>>>>>>>>>>>>>>>> references" in the definition of the program or the
>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The program D makes a simple copy of its input, which
>>>>>>>>>>>>>>>>>> is a
>>>>>>>>>>>>>>>>>> finite operation and then goes into its copy of the
>>>>>>>>>>>>>>>>>> program H.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Program H, to be a decider, must return an answer in a
>>>>>>>>>>>>>>>>>> finite
>>>>>>>>>>>>>>>>>> amount of time.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> A valid SHD with sufficient resources will return an
>>>>>>>>>>>>>>>>> answer in
>>>>>>>>>>>>>>>>> a finite amount of time.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Then so will D (unless the answer H gives is Halting,
>>>>>>>>>>>>>>>> then for
>>>>>>>>>>>>>>>> the Linz "D", D will just loop to show H wrong. For
>>>>>>>>>>>>>>>> Sipser, D
>>>>>>>>>>>>>>>> will just return 0 to make H wrong.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You can't argue that D doesn't return due to an infinite
>>>>>>>>>>>>>>>> recursion, but H does, as the only recursion possible is
>>>>>>>>>>>>>>>> mutual.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Nope. H isn't D. If D references H in such a way that
>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>> recursion would result (i.e. D is pathological) then D is
>>>>>>>>>>>>>>> not a
>>>>>>>>>>>>>>> program. Note: *ONLY* the Flibble Signaling Simulating Halt
>>>>>>>>>>>>>>> Decider can handle this situation properly.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Program H doesn't "reference" the input, it was just
>>>>>>>>>>>>>>>>>> provided
>>>>>>>>>>>>>>>>>> as its input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Program H doesn't "call" D, it decides based on the
>>>>>>>>>>>>>>>>>> representation of D.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If H gets its self stuck in the loop you described,
>>>>>>>>>>>>>>>>>> that just
>>>>>>>>>>>>>>>>>> means that H faisl to meet its requirements. This is a
>>>>>>>>>>>>>>>>>> known
>>>>>>>>>>>>>>>>>> issue with trying to halt decide by just emulation.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Nope. It only gets "stuck in the loop" if the input is "an
>>>>>>>>>>>>>>>>> impossible program" as per [Strachey 1965] i.e. invalid
>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>> which necessitates a halting decision of "not a
>>>>>>>>>>>>>>>>> program"; it is
>>>>>>>>>>>>>>>>> valid to "abort" the simulation when such a "loop" is
>>>>>>>>>>>>>>>>> detected
>>>>>>>>>>>>>>>>> (where I agree with Olcott) and return a halting
>>>>>>>>>>>>>>>>> decision of
>>>>>>>>>>>>>>>>> "not a program" (where I disagree with Olcott).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And the "impossible program" is a valid program, so you
>>>>>>>>>>>>>>>> are just
>>>>>>>>>>>>>>>> admitting that you H can't answer for all valid programs.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> LOL. Of course the impossible program is not a valid
>>>>>>>>>>>>>>> program: you
>>>>>>>>>>>>>>> seem to lack an understanding of simple English words.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Validity of a program is a SYNTAX decision, and D IS a
>>>>>>>>>>>>>>>> valid
>>>>>>>>>>>>>>>> program if H is.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I guess you just don't understand what a program is.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Note, YOUR definition leads to the contradiction that D
>>>>>>>>>>>>>>>> IS a
>>>>>>>>>>>>>>>> valid program if given to a DIFFERENT version of the
>>>>>>>>>>>>>>>> decider,
>>>>>>>>>>>>>>>> but isn't if given to this version.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The validity of a program, as to BEING a program, is a
>>>>>>>>>>>>>>>> universal
>>>>>>>>>>>>>>>> truth.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> All you are proving is that your H can't accept *ALL*
>>>>>>>>>>>>>>>> Programs,
>>>>>>>>>>>>>>>> as requried by the problem definition.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Nope. The Flibble Signaling Simulating Halt Decider can
>>>>>>>>>>>>>>> accept
>>>>>>>>>>>>>>> *ALL* valid programs and *ALL* invalid programs and is
>>>>>>>>>>>>>>> capable of
>>>>>>>>>>>>>>> distinguishing between the two types.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nope, D uses a copy of H, modifying according to acceptable
>>>>>>>>>>>>>> program modifications so D WILL be a program if H is,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Note "Valid" for programs means is a set of instructions that
>>>>>>>>>>>>>> produces a definitive results. Since H needs to do that,
>>>>>>>>>>>>>> so will
>>>>>>>>>>>>>> D, and thus D IS "Valid".
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The only "Qualification" the decider gets to use for
>>>>>>>>>>>>>> "valid" is if
>>>>>>>>>>>>>> it actually represents an actual program.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Some "Descriptions" that it can be given might not meet
>>>>>>>>>>>>>> the syntax
>>>>>>>>>>>>>> requriements to be a program. Those could be rejected as
>>>>>>>>>>>>>> "Not A
>>>>>>>>>>>>>> Program", but D doesn't fall into that category.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Syntax requirements?! LOLWUT! You clearly have no clue
>>>>>>>>>>>>> about what
>>>>>>>>>>>>> you are talking about. This has nothing to do with "syntax"
>>>>>>>>>>>>> whatsoever you twit.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, shows YOU don't know what you are talking about.
>>>>>>>>>>>>
>>>>>>>>>>>> The only thing that makes an input not a valid program is if it
>>>>>>>>>>>> fails the SYNTAX check.
>>>>>>>>>>>>
>>>>>>>>>>>> There are no "Semantics" that define what is a valid
>>>>>>>>>>>> program, only
>>>>>>>>>>>> syntactic criteria.
>>>>>>>>>>>>
>>>>>>>>>>>> What the execution of the program does is Semantics, that it
>>>>>>>>>>>> CAN be
>>>>>>>>>>>> executed is syntax.
>>>>>>>>>>>
>>>>>>>>>>> You have no clue! Nobody is denying that a program that can't be
>>>>>>>>>>> compiled due to a syntax error is invalid; in this case
>>>>>>>>>>> however the
>>>>>>>>>>> program is invalid for a different reason: the infinitely
>>>>>>>>>>> recursive
>>>>>>>>>>> relationship between the program and the halt decider, a
>>>>>>>>>>> category error.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>> Nope, a program that goes into an infinite loop is a perfectly
>>>>>>>>>> fine
>>>>>>>>>> program.
>>>>>>>>>>
>>>>>>>>>> There is nothing "invalid" about the design of the program D,
>>>>>>>>>> it just
>>>>>>>>>> makes it impossible for H to give the right answer.
>>>>>>>>>>
>>>>>>>>>> Please point out where in the definition of a "Program" there
>>>>>>>>>> is any
>>>>>>>>>> grounds to call "D" as not valid?
>>>>>>>>>>
>>>>>>>>>> You are just proving that you aren't a "Troll", but an "Idiot".
>>>>>>>>>
>>>>>>>>> You have no clue! You are such a beginner!
>>>>>>>>>
>>>>>>>>> First off infinite recursion and infinite loop are two
>>>>>>>>> different things.
>>>>>>>>>
>>>>>>>>> Secondly the infinite recursion only manifests when the halt
>>>>>>>>> decider is
>>>>>>>>> of the simulating type; if the halt decider is of the
>>>>>>>>> non-simulating
>>>>>>>>> type there is no infinite recursion as it isn't possible to
>>>>>>>>> even build
>>>>>>>>> the program in the first place as the program cannot even exist
>>>>>>>>> due to
>>>>>>>>> infinite self reference in the problem definition, a category
>>>>>>>>> error.
>>>>>>>>>
>>>>>>>>> Who is more idiotic? The idiot or the idiot that argues with
>>>>>>>>> the idiot?
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>> Right, which just makes the Simulating Halt Decider an incorect
>>>>>>>> Halt
>>>>>>>> Decidder, not the input somehow "invalid".
>>>>>>>>
>>>>>>>> And, there is NO problem building the program D, (except that it is
>>>>>>>> impossible to have a correct H, just like for the same reason
>>>>>>>> there is
>>>>>>>> no correct Simulating Halt Decider).
>>>>>>>>
>>>>>>>> Any H that you build that CLAIMS to be a Halt Decider, clearly
>>>>>>>> allows
>>>>>>>> you to build a program D, and a representation for that program
>>>>>>>> to give
>>>>>>>> to D or H.
>>>>>>>>
>>>>>>>> There is no "infinite self reference" in the problem definition.
>>>>>>>>
>>>>>>>> An H is defined that claims to be correct.
>>>>>>>>
>>>>>>>> A D is built from it by a simple template.
>>>>>>>>
>>>>>>>> The Input it built by converting that program into a description.
>>>>>>>>
>>>>>>>> Then we can show that H must be incorrect.
>>>>>>>>
>>>>>>>> The exact same can be done with your "Simulating Halt Decider", and
>>>>>>>> there is ZERO grounds to call the input "Invalid" as it was
>>>>>>>> built by the
>>>>>>>> normal construction rules of a program from the program H.
>>>>>>>>
>>>>>>>> The only way that D can't meet the definition of a program is
>>>>>>>> for H to
>>>>>>>> fail to meet the definition.
>>>>>>>>
>>>>>>>>
>>>>>>>> As to why answer:
>>>>>>>>
>>>>>>>> Answer a fool according to his folly,
>>>>>>>> or he will be wise in his own eyes.
>>>>>>> "I seem to remember formal logicians disrespect this 'riddle' to
>>>>>>> a man or woman."
>>>>>> It's taken as being criterial for your being an illogical
>>>>>> bullshitter, etc.
>>>>>
>>>>> "If you think the Halting Problem is ill-posed, or was not
>>>>> definitely solved by Alan Turing... this might not be the newsgroup
>>>>> for you."
>>>>
>>>> The a herd of sheep cannot understand me because this herd stays
>>>> stuck on the groupthink error does not entail that I am incorrect.
>>>>
>>>> When a decision problem is defined as what yes/no answer can Bill say
>>>> that correctly predicts the answer that Harry will provide when Harry
>>>> makes sure to always provide the opposite of whatever Bill predicts.
>>>> This "decision problem" is equivalent to Russell's Barber Paradox.
>>>>
>>>> *The diagonal argument of the halting theorem has this exact same form*
>>>>
>>>> Russell's Paradox was abolished by correcting the mistakes of naive set
>>>> theory and establishing ZFC set theory as its basis.
>>>>
>>>> In other words a barber that says he shaves all those that do not shave
>>>> themselves was ultimately determined to simply be a liar.
>>>>
>>>> https://en.wikipedia.org/wiki/Barber_paradox
>>>>
>>>> https://en.wikipedia.org/wiki/Russell%27s_paradox
>>>>
>>>> A simulating halt decider overcomes the pathology of the halting
>>>> problem proofs.
>>>
>>> You are just repeating Mr Flibble's original research which is
>>> Copyright (c) 2022 Mr Flibble.  Your attempt to avoid copyright
>>> infringement by backtracking on the need for a ternary rather than
>>> binary halting result is transparent.  The only valid halting decider
>>> is the Flibble Signalling Simulating Halt Decider which is also
>>> Copyright (c) 2022 Mr Flibble.
>>>
>>> https://github.com/i42output/halting-problem/blob/main/README.txt
>>>
>>> /Flibble
>>
>> It is very well documented in this forum that I came up with the ternary
>> halt decider many years ago back in 2004 in my very first USENET post
>> about the halting problem.
>>
>> on sci.logic before I knew about comp.theory
>> On 6/6/2004 9:11 AM, Olcott wrote: sci.logic
>> [Alan Turing's Halting Problem is incorrectly formed]
>> Message-ID: <bCFwc.13980$Gx4.2537@bgtnsc04-news.ops.worldnet.att.net>
>>
>> I am sure that I am not the only one that came up with this idea.
>>
>> The key missing part is writing the actual code that detects and rejects
>> the pathological input. Although I have that now it is far less
>> important than correctly determining the actual halt status of the
>> otherwise "impossible" input.
>
> However you are not actually doing that.  The critical flaw in your work
> is that you abort your simulation without actually determining if the

On 18/03/2023 17:20, olcott wrote:
> On 3/18/2023 12:07 PM, Mr Flibble wrote:
>> On 18/03/2023 16:48, olcott wrote:
>>> On 3/18/2023 11:39 AM, Mr Flibble wrote:
>>>> On 18/03/2023 15:39, olcott wrote:
>>>>> On 3/18/2023 10:19 AM, Jeffrey Rubard wrote:
>>>>>> On Tuesday, March 14, 2023 at 2:09:26 PM UTC-7, Jeffrey Rubard wrote:
>>>>>>> On Tuesday, March 14, 2023 at 2:08:44 PM UTC-7, Jeffrey Rubard
>>>>>>> wrote:
>>>>>>>> On Saturday, March 11, 2023 at 2:11:46 PM UTC-8, Richard Damon
>>>>>>>> wrote:
>>>>>>>>> On 3/11/23 4:14 PM, Mr Flibble wrote:
>>>>>>>>>> On 11/03/2023 20:28, Richard Damon wrote:
>>>>>>>>>>> On 3/11/23 2:51 PM, Mr Flibble wrote:
>>>>>>>>>>>> On 11/03/2023 18:28, Richard Damon wrote:
>>>>>>>>>>>>> On 3/11/23 12:35 PM, Mr Flibble wrote:
>>>>>>>>>>>>>> On 11/03/2023 16:52, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/11/23 9:53 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>> On 11/03/2023 14:36, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/11/23 9:26 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>> On 11/03/2023 11:58, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/11/23 6:20 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>> On 11/03/2023 01:06, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/10/23 7:17 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>> On 10/03/2023 23:38, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/10/23 6:26 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 10/03/2023 22:38, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/10/2023 4:17 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/03/2023 21:45, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/6/2004 9:11 AM, Olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> One very simple transformation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem into a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> solvable problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>> is to convert the Boolean function
>>>>>>>>>>>>>>>>>>>>>>>>>>>> DoesItHalt() into
>>>>>>>>>>>>>>>>>>>>>>>>>>>> a tertiary response:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> True, False, Neither.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> if (DoesItHalt() == True)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> while(True) // loop forever
>>>>>>>>>>>>>>>>>>>>>>>>>>>> ;
>>>>>>>>>>>>>>>>>>>>>>>>>>>> else if (DoesItHalt() == False)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> return False;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> else if (DoesItHalt() == NeitherTrueNorFalse)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> return NeitherTrueNorFalse;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> So the original Halting Problem was incorrectly
>>>>>>>>>>>>>>>>>>>>>>>>>>>> formed specifically
>>>>>>>>>>>>>>>>>>>>>>>>>>>> because it was framed as a Boolean function,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> thus
>>>>>>>>>>>>>>>>>>>>>>>>>>>> failing to account
>>>>>>>>>>>>>>>>>>>>>>>>>>>> for possible inputs that result in a reply
>>>>>>>>>>>>>>>>>>>>>>>>>>>> other than
>>>>>>>>>>>>>>>>>>>>>>>>>>>> True or False.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Message-ID:
>>>>>>>>>>>>>>>>>>>>>>>>>>> <bCFwc.13980$Gx4....@bgtnsc04-news.ops.worldnet.att.net>
>>>>>>>>>>>>>>>>>>>>>>>>>>> [Alan Turing's Halting Problem is incorrectly
>>>>>>>>>>>>>>>>>>>>>>>>>>> formed]
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> This is my very first USENET post about the
>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting
>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem
>>>>>>>>>>>>>>>>>>>>>>>>>>> back On 6/6/2004 9:11 AM
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> And yet you have reversed your position and
>>>>>>>>>>>>>>>>>>>>>>>>>> instead of
>>>>>>>>>>>>>>>>>>>>>>>>>> creating a decider with a ternary result you
>>>>>>>>>>>>>>>>>>>>>>>>>> have gone
>>>>>>>>>>>>>>>>>>>>>>>>>> back to returning a binary result. This was
>>>>>>>>>>>>>>>>>>>>>>>>>> your fatal
>>>>>>>>>>>>>>>>>>>>>>>>>> mistake, a mistake you probably made due to
>>>>>>>>>>>>>>>>>>>>>>>>>> you naively
>>>>>>>>>>>>>>>>>>>>>>>>>> being convinced by the received (but
>>>>>>>>>>>>>>>>>>>>>>>>>> erroneous) wisdom
>>>>>>>>>>>>>>>>>>>>>>>>>> of others.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> 01 int D(int (*x)())
>>>>>>>>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>>>>>>>>> 03 int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>> 04 if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>> 05 HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>> 06 return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Since D correctly simulated by H cannot
>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach
>>>>>>>>>>>>>>>>>>>>>>>>> its own final
>>>>>>>>>>>>>>>>>>>>>>>>> state "return" instruction in any finite number is
>>>>>>>>>>>>>>>>>>>>>>>>> simulated steps H is
>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to reject its input D as
>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *The simulated D cannot possibly get past its
>>>>>>>>>>>>>>>>>>>>>>>>> own line 03*
>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) simulates D(D) that calls H(D,D) to
>>>>>>>>>>>>>>>>>>>>>>>>> simulate
>>>>>>>>>>>>>>>>>>>>>>>>> itself again...
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> An invalid program neither halts nor doesn't halt.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> So D can't be an invalid program as it will
>>>>>>>>>>>>>>>>>>>>>>> always either
>>>>>>>>>>>>>>>>>>>>>>> Halt or Not depending on the definiton of H. The
>>>>>>>>>>>>>>>>>>>>>>> only way
>>>>>>>>>>>>>>>>>>>>>>> for D to not be a valid program is if H isn't a
>>>>>>>>>>>>>>>>>>>>>>> valid
>>>>>>>>>>>>>>>>>>>>>>> program, and then H can't be a correct halt decider.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> WRONG. The reason is subtle. It isn't that D is
>>>>>>>>>>>>>>>>>>>>>> invalid,
>>>>>>>>>>>>>>>>>>>>>> or that H isn't a correct halt decider, what is
>>>>>>>>>>>>>>>>>>>>>> invalid is
>>>>>>>>>>>>>>>>>>>>>> the COMBINATION of D and H. The combination is the
>>>>>>>>>>>>>>>>>>>>>> category error (the Impossible Program of
>>>>>>>>>>>>>>>>>>>>>> [Strachey 1965]).
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Not possible.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Either D is or is not a program.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If it is, then ALL Halt decider need to be able to
>>>>>>>>>>>>>>>>>>>>> decide
>>>>>>>>>>>>>>>>>>>>> it, even H.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> That comes from the meaning of **ALL**
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> D is not a program as it references H which
>>>>>>>>>>>>>>>>>>>> references D
>>>>>>>>>>>>>>>>>>>> which references H .. ad infinitum. This recursion is a
>>>>>>>>>>>>>>>>>>>> manifestation of the category error present in the
>>>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>>>> definition and is only present if the halt decider
>>>>>>>>>>>>>>>>>>>> is of the
>>>>>>>>>>>>>>>>>>>> simulating type (only SHDs can detect and report on the
>>>>>>>>>>>>>>>>>>>> pathology via a third result); so:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> 1) Only SHDs can solve the halting problem;
>>>>>>>>>>>>>>>>>>>> 2) SHDs must have a ternary result as invalid programs
>>>>>>>>>>>>>>>>>>>> neither halt nor don't halt.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> This unique insight is attributable to Mr Flibble
>>>>>>>>>>>>>>>>>>>> who is the
>>>>>>>>>>>>>>>>>>>> only person to have solved the halting problem.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So, you don;t understand how it is setup at all.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Yes, D is a program, built off the code of H, which
>>>>>>>>>>>>>>>>>>> needs to
>>>>>>>>>>>>>>>>>>> be program to meet the specifications.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> By specifications, program H is considered as a
>>>>>>>>>>>>>>>>>>> fundamental unit.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> D is given as an input, a finite string
>>>>>>>>>>>>>>>>>>> representation of this
>>>>>>>>>>>>>>>>>>> program D. All programs have a finite string
>>>>>>>>>>>>>>>>>>> repesentation.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Thus, D references a copy of H, and is given a copy
>>>>>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>>>>>> finite string representation of itself. Thus no
>>>>>>>>>>>>>>>>>>> "recursion of
>>>>>>>>>>>>>>>>>>> references" in the definition of the program or the
>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The program D makes a simple copy of its input, which
>>>>>>>>>>>>>>>>>>> is a
>>>>>>>>>>>>>>>>>>> finite operation and then goes into its copy of the
>>>>>>>>>>>>>>>>>>> program H.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Program H, to be a decider, must return an answer in
>>>>>>>>>>>>>>>>>>> a finite
>>>>>>>>>>>>>>>>>>> amount of time.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> A valid SHD with sufficient resources will return an
>>>>>>>>>>>>>>>>>> answer in
>>>>>>>>>>>>>>>>>> a finite amount of time.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Then so will D (unless the answer H gives is Halting,
>>>>>>>>>>>>>>>>> then for
>>>>>>>>>>>>>>>>> the Linz "D", D will just loop to show H wrong. For
>>>>>>>>>>>>>>>>> Sipser, D
>>>>>>>>>>>>>>>>> will just return 0 to make H wrong.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You can't argue that D doesn't return due to an infinite
>>>>>>>>>>>>>>>>> recursion, but H does, as the only recursion possible
>>>>>>>>>>>>>>>>> is mutual.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope. H isn't D. If D references H in such a way that
>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>> recursion would result (i.e. D is pathological) then D
>>>>>>>>>>>>>>>> is not a
>>>>>>>>>>>>>>>> program. Note: *ONLY* the Flibble Signaling Simulating Halt
>>>>>>>>>>>>>>>> Decider can handle this situation properly.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Program H doesn't "reference" the input, it was just
>>>>>>>>>>>>>>>>>>> provided
>>>>>>>>>>>>>>>>>>> as its input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Program H doesn't "call" D, it decides based on the
>>>>>>>>>>>>>>>>>>> representation of D.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If H gets its self stuck in the loop you described,
>>>>>>>>>>>>>>>>>>> that just
>>>>>>>>>>>>>>>>>>> means that H faisl to meet its requirements. This is
>>>>>>>>>>>>>>>>>>> a known
>>>>>>>>>>>>>>>>>>> issue with trying to halt decide by just emulation.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Nope. It only gets "stuck in the loop" if the input is
>>>>>>>>>>>>>>>>>> "an
>>>>>>>>>>>>>>>>>> impossible program" as per [Strachey 1965] i.e.
>>>>>>>>>>>>>>>>>> invalid input
>>>>>>>>>>>>>>>>>> which necessitates a halting decision of "not a
>>>>>>>>>>>>>>>>>> program"; it is
>>>>>>>>>>>>>>>>>> valid to "abort" the simulation when such a "loop" is
>>>>>>>>>>>>>>>>>> detected
>>>>>>>>>>>>>>>>>> (where I agree with Olcott) and return a halting
>>>>>>>>>>>>>>>>>> decision of
>>>>>>>>>>>>>>>>>> "not a program" (where I disagree with Olcott).
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And the "impossible program" is a valid program, so you
>>>>>>>>>>>>>>>>> are just
>>>>>>>>>>>>>>>>> admitting that you H can't answer for all valid programs.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> LOL. Of course the impossible program is not a valid
>>>>>>>>>>>>>>>> program: you
>>>>>>>>>>>>>>>> seem to lack an understanding of simple English words.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Validity of a program is a SYNTAX decision, and D IS a
>>>>>>>>>>>>>>>>> valid
>>>>>>>>>>>>>>>>> program if H is.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I guess you just don't understand what a program is.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Note, YOUR definition leads to the contradiction that D
>>>>>>>>>>>>>>>>> IS a
>>>>>>>>>>>>>>>>> valid program if given to a DIFFERENT version of the
>>>>>>>>>>>>>>>>> decider,
>>>>>>>>>>>>>>>>> but isn't if given to this version.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The validity of a program, as to BEING a program, is a
>>>>>>>>>>>>>>>>> universal
>>>>>>>>>>>>>>>>> truth.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> All you are proving is that your H can't accept *ALL*
>>>>>>>>>>>>>>>>> Programs,
>>>>>>>>>>>>>>>>> as requried by the problem definition.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope. The Flibble Signaling Simulating Halt Decider can
>>>>>>>>>>>>>>>> accept
>>>>>>>>>>>>>>>> *ALL* valid programs and *ALL* invalid programs and is
>>>>>>>>>>>>>>>> capable of
>>>>>>>>>>>>>>>> distinguishing between the two types.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Nope, D uses a copy of H, modifying according to acceptable
>>>>>>>>>>>>>>> program modifications so D WILL be a program if H is,
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Note "Valid" for programs means is a set of instructions
>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>> produces a definitive results. Since H needs to do that,
>>>>>>>>>>>>>>> so will
>>>>>>>>>>>>>>> D, and thus D IS "Valid".
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The only "Qualification" the decider gets to use for
>>>>>>>>>>>>>>> "valid" is if
>>>>>>>>>>>>>>> it actually represents an actual program.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Some "Descriptions" that it can be given might not meet
>>>>>>>>>>>>>>> the syntax
>>>>>>>>>>>>>>> requriements to be a program. Those could be rejected as
>>>>>>>>>>>>>>> "Not A
>>>>>>>>>>>>>>> Program", but D doesn't fall into that category.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Syntax requirements?! LOLWUT! You clearly have no clue
>>>>>>>>>>>>>> about what
>>>>>>>>>>>>>> you are talking about. This has nothing to do with "syntax"
>>>>>>>>>>>>>> whatsoever you twit.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope, shows YOU don't know what you are talking about.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The only thing that makes an input not a valid program is
>>>>>>>>>>>>> if it
>>>>>>>>>>>>> fails the SYNTAX check.
>>>>>>>>>>>>>
>>>>>>>>>>>>> There are no "Semantics" that define what is a valid
>>>>>>>>>>>>> program, only
>>>>>>>>>>>>> syntactic criteria.
>>>>>>>>>>>>>
>>>>>>>>>>>>> What the execution of the program does is Semantics, that
>>>>>>>>>>>>> it CAN be
>>>>>>>>>>>>> executed is syntax.
>>>>>>>>>>>>
>>>>>>>>>>>> You have no clue! Nobody is denying that a program that
>>>>>>>>>>>> can't be
>>>>>>>>>>>> compiled due to a syntax error is invalid; in this case
>>>>>>>>>>>> however the
>>>>>>>>>>>> program is invalid for a different reason: the infinitely
>>>>>>>>>>>> recursive
>>>>>>>>>>>> relationship between the program and the halt decider, a
>>>>>>>>>>>> category error.
>>>>>>>>>>>>
>>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>> Nope, a program that goes into an infinite loop is a
>>>>>>>>>>> perfectly fine
>>>>>>>>>>> program.
>>>>>>>>>>>
>>>>>>>>>>> There is nothing "invalid" about the design of the program D,
>>>>>>>>>>> it just
>>>>>>>>>>> makes it impossible for H to give the right answer.
>>>>>>>>>>>
>>>>>>>>>>> Please point out where in the definition of a "Program" there
>>>>>>>>>>> is any
>>>>>>>>>>> grounds to call "D" as not valid?
>>>>>>>>>>>
>>>>>>>>>>> You are just proving that you aren't a "Troll", but an "Idiot".
>>>>>>>>>>
>>>>>>>>>> You have no clue! You are such a beginner!
>>>>>>>>>>
>>>>>>>>>> First off infinite recursion and infinite loop are two
>>>>>>>>>> different things.
>>>>>>>>>>
>>>>>>>>>> Secondly the infinite recursion only manifests when the halt
>>>>>>>>>> decider is
>>>>>>>>>> of the simulating type; if the halt decider is of the
>>>>>>>>>> non-simulating
>>>>>>>>>> type there is no infinite recursion as it isn't possible to
>>>>>>>>>> even build
>>>>>>>>>> the program in the first place as the program cannot even
>>>>>>>>>> exist due to
>>>>>>>>>> infinite self reference in the problem definition, a category
>>>>>>>>>> error.
>>>>>>>>>>
>>>>>>>>>> Who is more idiotic? The idiot or the idiot that argues with
>>>>>>>>>> the idiot?
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>> Right, which just makes the Simulating Halt Decider an incorect
>>>>>>>>> Halt
>>>>>>>>> Decidder, not the input somehow "invalid".
>>>>>>>>>
>>>>>>>>> And, there is NO problem building the program D, (except that
>>>>>>>>> it is
>>>>>>>>> impossible to have a correct H, just like for the same reason
>>>>>>>>> there is
>>>>>>>>> no correct Simulating Halt Decider).
>>>>>>>>>
>>>>>>>>> Any H that you build that CLAIMS to be a Halt Decider, clearly
>>>>>>>>> allows
>>>>>>>>> you to build a program D, and a representation for that program
>>>>>>>>> to give
>>>>>>>>> to D or H.
>>>>>>>>>
>>>>>>>>> There is no "infinite self reference" in the problem definition.
>>>>>>>>>
>>>>>>>>> An H is defined that claims to be correct.
>>>>>>>>>
>>>>>>>>> A D is built from it by a simple template.
>>>>>>>>>
>>>>>>>>> The Input it built by converting that program into a description.
>>>>>>>>>
>>>>>>>>> Then we can show that H must be incorrect.
>>>>>>>>>
>>>>>>>>> The exact same can be done with your "Simulating Halt Decider",
>>>>>>>>> and
>>>>>>>>> there is ZERO grounds to call the input "Invalid" as it was
>>>>>>>>> built by the
>>>>>>>>> normal construction rules of a program from the program H.
>>>>>>>>>
>>>>>>>>> The only way that D can't meet the definition of a program is
>>>>>>>>> for H to
>>>>>>>>> fail to meet the definition.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> As to why answer:
>>>>>>>>>
>>>>>>>>> Answer a fool according to his folly,
>>>>>>>>> or he will be wise in his own eyes.
>>>>>>>> "I seem to remember formal logicians disrespect this 'riddle' to
>>>>>>>> a man or woman."
>>>>>>> It's taken as being criterial for your being an illogical
>>>>>>> bullshitter, etc.
>>>>>>
>>>>>> "If you think the Halting Problem is ill-posed, or was not
>>>>>> definitely solved by Alan Turing... this might not be the
>>>>>> newsgroup for you."
>>>>>
>>>>> The a herd of sheep cannot understand me because this herd stays
>>>>> stuck on the groupthink error does not entail that I am incorrect.
>>>>>
>>>>> When a decision problem is defined as what yes/no answer can Bill say
>>>>> that correctly predicts the answer that Harry will provide when Harry
>>>>> makes sure to always provide the opposite of whatever Bill predicts.
>>>>> This "decision problem" is equivalent to Russell's Barber Paradox.
>>>>>
>>>>> *The diagonal argument of the halting theorem has this exact same
>>>>> form*
>>>>>
>>>>> Russell's Paradox was abolished by correcting the mistakes of naive
>>>>> set
>>>>> theory and establishing ZFC set theory as its basis.
>>>>>
>>>>> In other words a barber that says he shaves all those that do not
>>>>> shave
>>>>> themselves was ultimately determined to simply be a liar.
>>>>>
>>>>> https://en.wikipedia.org/wiki/Barber_paradox
>>>>>
>>>>> https://en.wikipedia.org/wiki/Russell%27s_paradox
>>>>>
>>>>> A simulating halt decider overcomes the pathology of the halting
>>>>> problem proofs.
>>>>
>>>> You are just repeating Mr Flibble's original research which is
>>>> Copyright (c) 2022 Mr Flibble.  Your attempt to avoid copyright
>>>> infringement by backtracking on the need for a ternary rather than
>>>> binary halting result is transparent.  The only valid halting
>>>> decider is the Flibble Signalling Simulating Halt Decider which is
>>>> also Copyright (c) 2022 Mr Flibble.
>>>>
>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
>>>>
>>>> /Flibble
>>>
>>> It is very well documented in this forum that I came up with the ternary
>>> halt decider many years ago back in 2004 in my very first USENET post
>>> about the halting problem.
>>>
>>> on sci.logic before I knew about comp.theory
>>> On 6/6/2004 9:11 AM, Olcott wrote: sci.logic
>>> [Alan Turing's Halting Problem is incorrectly formed]
>>> Message-ID: <bCFwc.13980$Gx4.2537@bgtnsc04-news.ops.worldnet.att.net>
>>>
>>> I am sure that I am not the only one that came up with this idea.
>>>
>>> The key missing part is writing the actual code that detects and rejects
>>> the pathological input. Although I have that now it is far less
>>> important than correctly determining the actual halt status of the
>>> otherwise "impossible" input.
>>
>> However you are not actually doing that.  The critical flaw in your
>> work is that you abort your simulation without actually determining if
>> the
>
> My 2004 work is the same as your current work, I just replied to my 2004
> work so that you can see that it is the same.

On 3/18/2023 12:27 PM, Mr Flibble wrote:
> On 18/03/2023 17:20, olcott wrote:
>> On 3/18/2023 12:07 PM, Mr Flibble wrote:
>>> On 18/03/2023 16:48, olcott wrote:
>>>> On 3/18/2023 11:39 AM, Mr Flibble wrote:
>>>>> On 18/03/2023 15:39, olcott wrote:
>>>>>> On 3/18/2023 10:19 AM, Jeffrey Rubard wrote:
>>>>>>> On Tuesday, March 14, 2023 at 2:09:26 PM UTC-7, Jeffrey Rubard
>>>>>>> wrote:
>>>>>>>> On Tuesday, March 14, 2023 at 2:08:44 PM UTC-7, Jeffrey Rubard
>>>>>>>> wrote:
>>>>>>>>> On Saturday, March 11, 2023 at 2:11:46 PM UTC-8, Richard Damon
>>>>>>>>> wrote:
>>>>>>>>>> On 3/11/23 4:14 PM, Mr Flibble wrote:
>>>>>>>>>>> On 11/03/2023 20:28, Richard Damon wrote:
>>>>>>>>>>>> On 3/11/23 2:51 PM, Mr Flibble wrote:
>>>>>>>>>>>>> On 11/03/2023 18:28, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/11/23 12:35 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On 11/03/2023 16:52, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/11/23 9:53 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On 11/03/2023 14:36, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/11/23 9:26 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> On 11/03/2023 11:58, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/11/23 6:20 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>> On 11/03/2023 01:06, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/10/23 7:17 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 10/03/2023 23:38, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/10/23 6:26 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 10/03/2023 22:38, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/10/2023 4:17 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 10/03/2023 21:45, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/6/2004 9:11 AM, Olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> One very simple transformation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem into a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> solvable problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is to convert the Boolean function
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DoesItHalt() into
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a tertiary response:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> True, False, Neither.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if (DoesItHalt() == True)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> while(True) // loop forever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> else if (DoesItHalt() == False)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return False;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> else if (DoesItHalt() == NeitherTrueNorFalse)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return NeitherTrueNorFalse;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So the original Halting Problem was
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrectly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> formed specifically
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because it was framed as a Boolean
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> function, thus
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> failing to account
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for possible inputs that result in a reply
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> other than
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> True or False.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Message-ID:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> <bCFwc.13980$Gx4....@bgtnsc04-news.ops.worldnet.att.net>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> [Alan Turing's Halting Problem is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrectly formed]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is my very first USENET post about the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>> back On 6/6/2004 9:11 AM
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> And yet you have reversed your position and
>>>>>>>>>>>>>>>>>>>>>>>>>>> instead of
>>>>>>>>>>>>>>>>>>>>>>>>>>> creating a decider with a ternary result you
>>>>>>>>>>>>>>>>>>>>>>>>>>> have gone
>>>>>>>>>>>>>>>>>>>>>>>>>>> back to returning a binary result. This was
>>>>>>>>>>>>>>>>>>>>>>>>>>> your fatal
>>>>>>>>>>>>>>>>>>>>>>>>>>> mistake, a mistake you probably made due to
>>>>>>>>>>>>>>>>>>>>>>>>>>> you naively
>>>>>>>>>>>>>>>>>>>>>>>>>>> being convinced by the received (but
>>>>>>>>>>>>>>>>>>>>>>>>>>> erroneous) wisdom
>>>>>>>>>>>>>>>>>>>>>>>>>>> of others.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> 01 int D(int (*x)())
>>>>>>>>>>>>>>>>>>>>>>>>>> 02 {
>>>>>>>>>>>>>>>>>>>>>>>>>> 03 int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>> 04 if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>> 05 HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>> 06 return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>>>>> 07 }
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Since D correctly simulated by H cannot
>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach
>>>>>>>>>>>>>>>>>>>>>>>>>> its own final
>>>>>>>>>>>>>>>>>>>>>>>>>> state "return" instruction in any finite
>>>>>>>>>>>>>>>>>>>>>>>>>> number is
>>>>>>>>>>>>>>>>>>>>>>>>>> simulated steps H is
>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct to reject its input D as
>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> *The simulated D cannot possibly get past its
>>>>>>>>>>>>>>>>>>>>>>>>>> own line 03*
>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) simulates D(D) that calls H(D,D) to
>>>>>>>>>>>>>>>>>>>>>>>>>> simulate
>>>>>>>>>>>>>>>>>>>>>>>>>> itself again...
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> An invalid program neither halts nor doesn't halt.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So D can't be an invalid program as it will
>>>>>>>>>>>>>>>>>>>>>>>> always either
>>>>>>>>>>>>>>>>>>>>>>>> Halt or Not depending on the definiton of H. The
>>>>>>>>>>>>>>>>>>>>>>>> only way
>>>>>>>>>>>>>>>>>>>>>>>> for D to not be a valid program is if H isn't a
>>>>>>>>>>>>>>>>>>>>>>>> valid
>>>>>>>>>>>>>>>>>>>>>>>> program, and then H can't be a correct halt
>>>>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> WRONG. The reason is subtle. It isn't that D is
>>>>>>>>>>>>>>>>>>>>>>> invalid,
>>>>>>>>>>>>>>>>>>>>>>> or that H isn't a correct halt decider, what is
>>>>>>>>>>>>>>>>>>>>>>> invalid is
>>>>>>>>>>>>>>>>>>>>>>> the COMBINATION of D and H. The combination is the
>>>>>>>>>>>>>>>>>>>>>>> category error (the Impossible Program of
>>>>>>>>>>>>>>>>>>>>>>> [Strachey 1965]).
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Not possible.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Either D is or is not a program.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If it is, then ALL Halt decider need to be able to
>>>>>>>>>>>>>>>>>>>>>> decide
>>>>>>>>>>>>>>>>>>>>>> it, even H.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> That comes from the meaning of **ALL**
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> D is not a program as it references H which
>>>>>>>>>>>>>>>>>>>>> references D
>>>>>>>>>>>>>>>>>>>>> which references H .. ad infinitum. This recursion
>>>>>>>>>>>>>>>>>>>>> is a
>>>>>>>>>>>>>>>>>>>>> manifestation of the category error present in the
>>>>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>>>>> definition and is only present if the halt decider
>>>>>>>>>>>>>>>>>>>>> is of the
>>>>>>>>>>>>>>>>>>>>> simulating type (only SHDs can detect and report on
>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>> pathology via a third result); so:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> 1) Only SHDs can solve the halting problem;
>>>>>>>>>>>>>>>>>>>>> 2) SHDs must have a ternary result as invalid programs
>>>>>>>>>>>>>>>>>>>>> neither halt nor don't halt.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> This unique insight is attributable to Mr Flibble
>>>>>>>>>>>>>>>>>>>>> who is the
>>>>>>>>>>>>>>>>>>>>> only person to have solved the halting problem.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> So, you don;t understand how it is setup at all.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Yes, D is a program, built off the code of H, which
>>>>>>>>>>>>>>>>>>>> needs to
>>>>>>>>>>>>>>>>>>>> be program to meet the specifications.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> By specifications, program H is considered as a
>>>>>>>>>>>>>>>>>>>> fundamental unit.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> D is given as an input, a finite string
>>>>>>>>>>>>>>>>>>>> representation of this
>>>>>>>>>>>>>>>>>>>> program D. All programs have a finite string
>>>>>>>>>>>>>>>>>>>> repesentation.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Thus, D references a copy of H, and is given a copy
>>>>>>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>>>>>>> finite string representation of itself. Thus no
>>>>>>>>>>>>>>>>>>>> "recursion of
>>>>>>>>>>>>>>>>>>>> references" in the definition of the program or the
>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The program D makes a simple copy of its input,
>>>>>>>>>>>>>>>>>>>> which is a
>>>>>>>>>>>>>>>>>>>> finite operation and then goes into its copy of the
>>>>>>>>>>>>>>>>>>>> program H.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Program H, to be a decider, must return an answer in
>>>>>>>>>>>>>>>>>>>> a finite
>>>>>>>>>>>>>>>>>>>> amount of time.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> A valid SHD with sufficient resources will return an
>>>>>>>>>>>>>>>>>>> answer in
>>>>>>>>>>>>>>>>>>> a finite amount of time.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Then so will D (unless the answer H gives is Halting,
>>>>>>>>>>>>>>>>>> then for
>>>>>>>>>>>>>>>>>> the Linz "D", D will just loop to show H wrong. For
>>>>>>>>>>>>>>>>>> Sipser, D
>>>>>>>>>>>>>>>>>> will just return 0 to make H wrong.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You can't argue that D doesn't return due to an infinite
>>>>>>>>>>>>>>>>>> recursion, but H does, as the only recursion possible
>>>>>>>>>>>>>>>>>> is mutual.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Nope. H isn't D. If D references H in such a way that
>>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>>> recursion would result (i.e. D is pathological) then D
>>>>>>>>>>>>>>>>> is not a
>>>>>>>>>>>>>>>>> program. Note: *ONLY* the Flibble Signaling Simulating
>>>>>>>>>>>>>>>>> Halt
>>>>>>>>>>>>>>>>> Decider can handle this situation properly.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Program H doesn't "reference" the input, it was just
>>>>>>>>>>>>>>>>>>>> provided
>>>>>>>>>>>>>>>>>>>> as its input.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Program H doesn't "call" D, it decides based on the
>>>>>>>>>>>>>>>>>>>> representation of D.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If H gets its self stuck in the loop you described,
>>>>>>>>>>>>>>>>>>>> that just
>>>>>>>>>>>>>>>>>>>> means that H faisl to meet its requirements. This is
>>>>>>>>>>>>>>>>>>>> a known
>>>>>>>>>>>>>>>>>>>> issue with trying to halt decide by just emulation.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Nope. It only gets "stuck in the loop" if the input
>>>>>>>>>>>>>>>>>>> is "an
>>>>>>>>>>>>>>>>>>> impossible program" as per [Strachey 1965] i.e.
>>>>>>>>>>>>>>>>>>> invalid input
>>>>>>>>>>>>>>>>>>> which necessitates a halting decision of "not a
>>>>>>>>>>>>>>>>>>> program"; it is
>>>>>>>>>>>>>>>>>>> valid to "abort" the simulation when such a "loop" is
>>>>>>>>>>>>>>>>>>> detected
>>>>>>>>>>>>>>>>>>> (where I agree with Olcott) and return a halting
>>>>>>>>>>>>>>>>>>> decision of
>>>>>>>>>>>>>>>>>>> "not a program" (where I disagree with Olcott).
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And the "impossible program" is a valid program, so
>>>>>>>>>>>>>>>>>> you are just
>>>>>>>>>>>>>>>>>> admitting that you H can't answer for all valid programs.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> LOL. Of course the impossible program is not a valid
>>>>>>>>>>>>>>>>> program: you
>>>>>>>>>>>>>>>>> seem to lack an understanding of simple English words.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Validity of a program is a SYNTAX decision, and D IS a
>>>>>>>>>>>>>>>>>> valid
>>>>>>>>>>>>>>>>>> program if H is.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I guess you just don't understand what a program is.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Note, YOUR definition leads to the contradiction that
>>>>>>>>>>>>>>>>>> D IS a
>>>>>>>>>>>>>>>>>> valid program if given to a DIFFERENT version of the
>>>>>>>>>>>>>>>>>> decider,
>>>>>>>>>>>>>>>>>> but isn't if given to this version.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The validity of a program, as to BEING a program, is a
>>>>>>>>>>>>>>>>>> universal
>>>>>>>>>>>>>>>>>> truth.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> All you are proving is that your H can't accept *ALL*
>>>>>>>>>>>>>>>>>> Programs,
>>>>>>>>>>>>>>>>>> as requried by the problem definition.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Nope. The Flibble Signaling Simulating Halt Decider can
>>>>>>>>>>>>>>>>> accept
>>>>>>>>>>>>>>>>> *ALL* valid programs and *ALL* invalid programs and is
>>>>>>>>>>>>>>>>> capable of
>>>>>>>>>>>>>>>>> distinguishing between the two types.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope, D uses a copy of H, modifying according to acceptable
>>>>>>>>>>>>>>>> program modifications so D WILL be a program if H is,
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Note "Valid" for programs means is a set of instructions
>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>> produces a definitive results. Since H needs to do that,
>>>>>>>>>>>>>>>> so will
>>>>>>>>>>>>>>>> D, and thus D IS "Valid".
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The only "Qualification" the decider gets to use for
>>>>>>>>>>>>>>>> "valid" is if
>>>>>>>>>>>>>>>> it actually represents an actual program.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Some "Descriptions" that it can be given might not meet
>>>>>>>>>>>>>>>> the syntax
>>>>>>>>>>>>>>>> requriements to be a program. Those could be rejected as
>>>>>>>>>>>>>>>> "Not A
>>>>>>>>>>>>>>>> Program", but D doesn't fall into that category.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Syntax requirements?! LOLWUT! You clearly have no clue
>>>>>>>>>>>>>>> about what
>>>>>>>>>>>>>>> you are talking about. This has nothing to do with "syntax"
>>>>>>>>>>>>>>> whatsoever you twit.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nope, shows YOU don't know what you are talking about.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The only thing that makes an input not a valid program is
>>>>>>>>>>>>>> if it
>>>>>>>>>>>>>> fails the SYNTAX check.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> There are no "Semantics" that define what is a valid
>>>>>>>>>>>>>> program, only
>>>>>>>>>>>>>> syntactic criteria.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> What the execution of the program does is Semantics, that
>>>>>>>>>>>>>> it CAN be
>>>>>>>>>>>>>> executed is syntax.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You have no clue! Nobody is denying that a program that
>>>>>>>>>>>>> can't be
>>>>>>>>>>>>> compiled due to a syntax error is invalid; in this case
>>>>>>>>>>>>> however the
>>>>>>>>>>>>> program is invalid for a different reason: the infinitely
>>>>>>>>>>>>> recursive
>>>>>>>>>>>>> relationship between the program and the halt decider, a
>>>>>>>>>>>>> category error.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, a program that goes into an infinite loop is a
>>>>>>>>>>>> perfectly fine
>>>>>>>>>>>> program.
>>>>>>>>>>>>
>>>>>>>>>>>> There is nothing "invalid" about the design of the program
>>>>>>>>>>>> D, it just
>>>>>>>>>>>> makes it impossible for H to give the right answer.
>>>>>>>>>>>>
>>>>>>>>>>>> Please point out where in the definition of a "Program"
>>>>>>>>>>>> there is any
>>>>>>>>>>>> grounds to call "D" as not valid?
>>>>>>>>>>>>
>>>>>>>>>>>> You are just proving that you aren't a "Troll", but an "Idiot".
>>>>>>>>>>>
>>>>>>>>>>> You have no clue! You are such a beginner!
>>>>>>>>>>>
>>>>>>>>>>> First off infinite recursion and infinite loop are two
>>>>>>>>>>> different things.
>>>>>>>>>>>
>>>>>>>>>>> Secondly the infinite recursion only manifests when the halt
>>>>>>>>>>> decider is
>>>>>>>>>>> of the simulating type; if the halt decider is of the
>>>>>>>>>>> non-simulating
>>>>>>>>>>> type there is no infinite recursion as it isn't possible to
>>>>>>>>>>> even build
>>>>>>>>>>> the program in the first place as the program cannot even
>>>>>>>>>>> exist due to
>>>>>>>>>>> infinite self reference in the problem definition, a category
>>>>>>>>>>> error.
>>>>>>>>>>>
>>>>>>>>>>> Who is more idiotic? The idiot or the idiot that argues with
>>>>>>>>>>> the idiot?
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>> Right, which just makes the Simulating Halt Decider an
>>>>>>>>>> incorect Halt
>>>>>>>>>> Decidder, not the input somehow "invalid".
>>>>>>>>>>
>>>>>>>>>> And, there is NO problem building the program D, (except that
>>>>>>>>>> it is
>>>>>>>>>> impossible to have a correct H, just like for the same reason
>>>>>>>>>> there is
>>>>>>>>>> no correct Simulating Halt Decider).
>>>>>>>>>>
>>>>>>>>>> Any H that you build that CLAIMS to be a Halt Decider, clearly
>>>>>>>>>> allows
>>>>>>>>>> you to build a program D, and a representation for that
>>>>>>>>>> program to give
>>>>>>>>>> to D or H.
>>>>>>>>>>
>>>>>>>>>> There is no "infinite self reference" in the problem definition.
>>>>>>>>>>
>>>>>>>>>> An H is defined that claims to be correct.
>>>>>>>>>>
>>>>>>>>>> A D is built from it by a simple template.
>>>>>>>>>>
>>>>>>>>>> The Input it built by converting that program into a description.
>>>>>>>>>>
>>>>>>>>>> Then we can show that H must be incorrect.
>>>>>>>>>>
>>>>>>>>>> The exact same can be done with your "Simulating Halt
>>>>>>>>>> Decider", and
>>>>>>>>>> there is ZERO grounds to call the input "Invalid" as it was
>>>>>>>>>> built by the
>>>>>>>>>> normal construction rules of a program from the program H.
>>>>>>>>>>
>>>>>>>>>> The only way that D can't meet the definition of a program is
>>>>>>>>>> for H to
>>>>>>>>>> fail to meet the definition.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> As to why answer:
>>>>>>>>>>
>>>>>>>>>> Answer a fool according to his folly,
>>>>>>>>>> or he will be wise in his own eyes.
>>>>>>>>> "I seem to remember formal logicians disrespect this 'riddle'
>>>>>>>>> to a man or woman."
>>>>>>>> It's taken as being criterial for your being an illogical
>>>>>>>> bullshitter, etc.
>>>>>>>
>>>>>>> "If you think the Halting Problem is ill-posed, or was not
>>>>>>> definitely solved by Alan Turing... this might not be the
>>>>>>> newsgroup for you."
>>>>>>
>>>>>> The a herd of sheep cannot understand me because this herd stays
>>>>>> stuck on the groupthink error does not entail that I am incorrect.
>>>>>>
>>>>>> When a decision problem is defined as what yes/no answer can Bill say
>>>>>> that correctly predicts the answer that Harry will provide when Harry
>>>>>> makes sure to always provide the opposite of whatever Bill predicts.
>>>>>> This "decision problem" is equivalent to Russell's Barber Paradox.
>>>>>>
>>>>>> *The diagonal argument of the halting theorem has this exact same
>>>>>> form*
>>>>>>
>>>>>> Russell's Paradox was abolished by correcting the mistakes of
>>>>>> naive set
>>>>>> theory and establishing ZFC set theory as its basis.
>>>>>>
>>>>>> In other words a barber that says he shaves all those that do not
>>>>>> shave
>>>>>> themselves was ultimately determined to simply be a liar.
>>>>>>
>>>>>> https://en.wikipedia.org/wiki/Barber_paradox
>>>>>>
>>>>>> https://en.wikipedia.org/wiki/Russell%27s_paradox
>>>>>>
>>>>>> A simulating halt decider overcomes the pathology of the halting
>>>>>> problem proofs.
>>>>>
>>>>> You are just repeating Mr Flibble's original research which is
>>>>> Copyright (c) 2022 Mr Flibble.  Your attempt to avoid copyright
>>>>> infringement by backtracking on the need for a ternary rather than
>>>>> binary halting result is transparent.  The only valid halting
>>>>> decider is the Flibble Signalling Simulating Halt Decider which is
>>>>> also Copyright (c) 2022 Mr Flibble.
>>>>>
>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
>>>>>
>>>>> /Flibble
>>>>
>>>> It is very well documented in this forum that I came up with the
>>>> ternary
>>>> halt decider many years ago back in 2004 in my very first USENET post
>>>> about the halting problem.
>>>>
>>>> on sci.logic before I knew about comp.theory
>>>> On 6/6/2004 9:11 AM, Olcott wrote: sci.logic
>>>> [Alan Turing's Halting Problem is incorrectly formed]
>>>> Message-ID: <bCFwc.13980$Gx4.2537@bgtnsc04-news.ops.worldnet.att.net>
>>>>
>>>> I am sure that I am not the only one that came up with this idea.
>>>>
>>>> The key missing part is writing the actual code that detects and
>>>> rejects
>>>> the pathological input. Although I have that now it is far less
>>>> important than correctly determining the actual halt status of the
>>>> otherwise "impossible" input.
>>>
>>> However you are not actually doing that.  The critical flaw in your
>>> work is that you abort your simulation without actually determining
>>> if the
>>
>> My 2004 work is the same as your current work, I just replied to my
>> 2004 work so that you can see that it is the same.
>
> Nope, the idea of forking the simulation into a halting and a
> non-halting branch is my idea and my idea alone: it is my unique
> contribution to Halting Problem research.
>
> /Flibble
>