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

--
Copyright 2023 Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

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

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...

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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

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.

On 3/10/2023 5: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

As you can see I thought the same thing 19 years ago. I thought that
because the halting problem was modeled after the Liar Paradox that it
was neither true nor false that D neither halted nor failed to halt. It
took me 12 more years to see this alternative view:

I accidentally discovered that the Peter Linz proof was infinitely recursive

It looks like the original specification provided in the
Linz text may be infinitely recursive in that each TM
requires its own input. *From page 3 of this paper*

When writing this paper
https://www.researchgate.net/publication/307509556_Self_Modifying_Turing_Machine_SMTM_Solution_to_the_Halting_Problem_concrete_example

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/10/2023 5:38 PM, 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.
>
>

*You are correct* It took me from 2004 to 2016 to realize this.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/10/23 6:39 PM, olcott wrote:
> On 3/10/2023 5: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
>
> As you can see I thought the same thing 19 years ago. I thought that
> because the halting problem was modeled after the Liar Paradox that it
> was neither true nor false that D neither halted nor failed to halt. It
> took me 12 more years to see this alternative view:
>
> I accidentally discovered that the Peter Linz proof was infinitely
> recursive
>
>    It looks like the original specification provided in the
>    Linz text may be infinitely recursive in that each TM
>    requires its own input. *From page 3 of this paper*
>
> When writing this paper
> https://www.researchgate.net/publication/307509556_Self_Modifying_Turing_Machine_SMTM_Solution_to_the_Halting_Problem_concrete_example
>

No, it is only infinitely recursive if H fails to answer.

If H(D,D) gives an answer when directly run, as is REQUIRED for H to be
a decider, then it will also give that exact same answer in finite time
when D(D) invokes its copy of H(D,D), and thus is not infinitely recursive.

You have accepted this fact by failing to provided the needed facts to
rebute this, which would be trivial to provide if your (sometime) claim
that they differ was true since you claim to have a working program for
this case.

On 10/03/2023 23:39, olcott wrote:
> On 3/10/2023 5: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
>
> As you can see I thought the same thing 19 years ago. I thought that
> because the halting problem was modeled after the Liar Paradox that it
> was neither true nor false that D neither halted nor failed to halt. It
> took me 12 more years to see this alternative view:
>
> I accidentally discovered that the Peter Linz proof was infinitely
> recursive
>
>    It looks like the original specification provided in the
>    Linz text may be infinitely recursive in that each TM
>    requires its own input. *From page 3 of this paper*
>
> When writing this paper
> https://www.researchgate.net/publication/307509556_Self_Modifying_Turing_Machine_SMTM_Solution_to_the_Halting_Problem_concrete_example
>

Then you are showing an inability to join the dots: the infinite
recursion is a manifestation of the category error that is trying to
decide if invalid programs halt or not.

/Flibble

On 3/10/2023 5:54 PM, Richard Damon wrote:
> On 3/10/23 6:39 PM, olcott wrote:
>> On 3/10/2023 5: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
>>
>> As you can see I thought the same thing 19 years ago. I thought that
>> because the halting problem was modeled after the Liar Paradox that it
>> was neither true nor false that D neither halted nor failed to halt. It
>> took me 12 more years to see this alternative view:
>>
>> I accidentally discovered that the Peter Linz proof was infinitely
>> recursive
>>
>>     It looks like the original specification provided in the
>>     Linz text may be infinitely recursive in that each TM
>>     requires its own input. *From page 3 of this paper*
>>
>> When writing this paper
>> https://www.researchgate.net/publication/307509556_Self_Modifying_Turing_Machine_SMTM_Solution_to_the_Halting_Problem_concrete_example
>>
>
> No, it is only infinitely recursive if H fails to answer.
>

Halting means reaches its own "return instruction" final state, D
correctly simulated by H cannot possibly do that no matter what H does
thus D simulated by H is unequivocally non-halting.

> If H(D,D) gives an answer when directly run, as is REQUIRED for H to be
> a decider, then it will also give that exact same answer in finite time
> when D(D) invokes its copy of H(D,D), and thus is not infinitely recursive.
>
> You have accepted this fact by failing to provided the needed facts to
> rebute this, which would be trivial to provide if your (sometime) claim
> that they differ was true since you claim to have a working program for
> this case.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/10/2023 5:58 PM, Mr Flibble wrote:
> On 10/03/2023 23:39, olcott wrote:
>> On 3/10/2023 5: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
>>
>> As you can see I thought the same thing 19 years ago. I thought that
>> because the halting problem was modeled after the Liar Paradox that it
>> was neither true nor false that D neither halted nor failed to halt. It
>> took me 12 more years to see this alternative view:
>>
>> I accidentally discovered that the Peter Linz proof was infinitely
>> recursive
>>
>>     It looks like the original specification provided in the
>>     Linz text may be infinitely recursive in that each TM
>>     requires its own input. *From page 3 of this paper*
>>
>> When writing this paper
>> https://www.researchgate.net/publication/307509556_Self_Modifying_Turing_Machine_SMTM_Solution_to_the_Halting_Problem_concrete_example
>>
>
> Then you are showing an inability to join the dots: the infinite
> recursion is a manifestation of the category error that is trying to
> decide if invalid programs halt or not.
>
> /Flibble

In other words you are saying that a program stuck in infinite recursion
neither halts nor fails to halt.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 11/03/2023 00:04, olcott wrote:
> On 3/10/2023 5:58 PM, Mr Flibble wrote:
>> On 10/03/2023 23:39, olcott wrote:
>>> On 3/10/2023 5: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
>>>
>>> As you can see I thought the same thing 19 years ago. I thought that
>>> because the halting problem was modeled after the Liar Paradox that it
>>> was neither true nor false that D neither halted nor failed to halt. It
>>> took me 12 more years to see this alternative view:
>>>
>>> I accidentally discovered that the Peter Linz proof was infinitely
>>> recursive
>>>
>>>     It looks like the original specification provided in the
>>>     Linz text may be infinitely recursive in that each TM
>>>     requires its own input. *From page 3 of this paper*
>>>
>>> When writing this paper
>>> https://www.researchgate.net/publication/307509556_Self_Modifying_Turing_Machine_SMTM_Solution_to_the_Halting_Problem_concrete_example
>>>
>>
>> Then you are showing an inability to join the dots: the infinite
>> recursion is a manifestation of the category error that is trying to
>> decide if invalid programs halt or not.
>>
>> /Flibble
>
>
> In other words you are saying that a program stuck in infinite recursion
> neither halts nor fails to halt.
>

*ONLY* if a halt decider is part of that infinite recursion.

/Flibble

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

On 3/10/2023 6: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

That would be true under the diagonal proof of the halting theorem.
In this case H is required to correctly predict the Boolean value that D
will return when D returns the opposite of whatever H predicts.

In this case we do have a kind of category error that it similar to my
original example of a category error from many years ago:

What time is it (yes or no) ?
In this case we have an incorrect rather than undecidable problem.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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**

On 3/10/23 7:03 PM, olcott wrote:
> On 3/10/2023 5:54 PM, Richard Damon wrote:
>> On 3/10/23 6:39 PM, olcott wrote:
>>> On 3/10/2023 5: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
>>>
>>> As you can see I thought the same thing 19 years ago. I thought that
>>> because the halting problem was modeled after the Liar Paradox that it
>>> was neither true nor false that D neither halted nor failed to halt. It
>>> took me 12 more years to see this alternative view:
>>>
>>> I accidentally discovered that the Peter Linz proof was infinitely
>>> recursive
>>>
>>>     It looks like the original specification provided in the
>>>     Linz text may be infinitely recursive in that each TM
>>>     requires its own input. *From page 3 of this paper*
>>>
>>> When writing this paper
>>> https://www.researchgate.net/publication/307509556_Self_Modifying_Turing_Machine_SMTM_Solution_to_the_Halting_Problem_concrete_example
>>>
>>
>> No, it is only infinitely recursive if H fails to answer.
>>
>
> Halting means reaches its own "return instruction" final state, D
> correctly simulated by H cannot possibly do that no matter what H does
> thus D simulated by H is unequivocally non-halting.

Except that Halting isn't defined by a simulation reaching the final
instruction, but by the actual machine when directly executed not
reaching the final instruction, which it does, as you have admitted.

It just shows that H's simuation isn't sufficent for it to show if the
input Halts or not.

>
>> If H(D,D) gives an answer when directly run, as is REQUIRED for H to
>> be a decider, then it will also give that exact same answer in finite
>> time when D(D) invokes its copy of H(D,D), and thus is not infinitely
>> recursive.
>>
>> You have accepted this fact by failing to provided the needed facts to
>> rebute this, which would be trivial to provide if your (sometime)
>> claim that they differ was true since you claim to have a working
>> program for this case.
>

On 3/10/2023 7:07 PM, Richard Damon wrote:
> On 3/10/23 7:03 PM, olcott wrote:
>> On 3/10/2023 5:54 PM, Richard Damon wrote:
>>> On 3/10/23 6:39 PM, olcott wrote:
>>>> On 3/10/2023 5: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
>>>>
>>>> As you can see I thought the same thing 19 years ago. I thought that
>>>> because the halting problem was modeled after the Liar Paradox that it
>>>> was neither true nor false that D neither halted nor failed to halt. It
>>>> took me 12 more years to see this alternative view:
>>>>
>>>> I accidentally discovered that the Peter Linz proof was infinitely
>>>> recursive
>>>>
>>>>     It looks like the original specification provided in the
>>>>     Linz text may be infinitely recursive in that each TM
>>>>     requires its own input. *From page 3 of this paper*
>>>>
>>>> When writing this paper
>>>> https://www.researchgate.net/publication/307509556_Self_Modifying_Turing_Machine_SMTM_Solution_to_the_Halting_Problem_concrete_example
>>>>
>>>
>>> No, it is only infinitely recursive if H fails to answer.
>>>
>>
>> Halting means reaches its own "return instruction" final state, D
>> correctly simulated by H cannot possibly do that no matter what H does
>> thus D simulated by H is unequivocally non-halting.
>
> Except that Halting isn't defined by a simulation reaching the final
> instruction, but by the actual machine when directly executed not
> reaching the final instruction, which it does, as you have admitted.
>

Maybe I should treat non-halting inputs as a divide-by-zero error and
abnormally terminate entire offending sequence.

The behavior of D(D) after H aborts its simulation of D is the same as
finishing a computation after there was a divide-by-zero error in this
computation.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/10/23 8:11 PM, olcott wrote:
> On 3/10/2023 7:07 PM, Richard Damon wrote:
>> On 3/10/23 7:03 PM, olcott wrote:
>>> On 3/10/2023 5:54 PM, Richard Damon wrote:
>>>> On 3/10/23 6:39 PM, olcott wrote:
>>>>> On 3/10/2023 5: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
>>>>>
>>>>> As you can see I thought the same thing 19 years ago. I thought that
>>>>> because the halting problem was modeled after the Liar Paradox that it
>>>>> was neither true nor false that D neither halted nor failed to
>>>>> halt. It
>>>>> took me 12 more years to see this alternative view:
>>>>>
>>>>> I accidentally discovered that the Peter Linz proof was infinitely
>>>>> recursive
>>>>>
>>>>>     It looks like the original specification provided in the
>>>>>     Linz text may be infinitely recursive in that each TM
>>>>>     requires its own input. *From page 3 of this paper*
>>>>>
>>>>> When writing this paper
>>>>> https://www.researchgate.net/publication/307509556_Self_Modifying_Turing_Machine_SMTM_Solution_to_the_Halting_Problem_concrete_example
>>>>>
>>>>
>>>> No, it is only infinitely recursive if H fails to answer.
>>>>
>>>
>>> Halting means reaches its own "return instruction" final state, D
>>> correctly simulated by H cannot possibly do that no matter what H does
>>> thus D simulated by H is unequivocally non-halting.
>>
>> Except that Halting isn't defined by a simulation reaching the final
>> instruction, but by the actual machine when directly executed not
>> reaching the final instruction, which it does, as you have admitted.
>>
>
> Maybe I should treat non-halting inputs as a divide-by-zero error and
> abnormally terminate entire offending sequence.

Nope, "abnormally terminating" is still halting for a computation, so
your decider fails to give the answer, but the actual program P that
used it still halted.

>
> The behavior of D(D) after H aborts its simulation of D is the same as
> finishing a computation after there was a divide-by-zero error in this
> computation.
>
>

Nope. You seem to have a blind spot here. The definition says to look at
the behavior of just running D(D), or in your programmng language case,
having main call D(D), and THAT program when run will halt as the H it
calls will return a 0 to it and it will return.

You seem to not understand that there IS a difference between the
simulation of the machine represented by the input and the actual
running of that machine.

You have even admitted that D(D) does Halt, you just try to lie that it
doesn't matter even though that is what the definition says does.

That just proves you don't understand what you are talking about.

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

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.

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.

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.

>
> 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

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.

>
>>
>> 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.

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.

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.

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

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.
>