On 5/25/2023 8:56 PM, Richard Damon wrote:
> On 5/25/23 9:43 PM, olcott wrote:
>> On 5/25/2023 8:29 PM, olcott wrote:
>>> On 5/25/2023 7:01 PM, Richard Damon wrote:
>>>> On 5/25/23 11:30 AM, olcott wrote:
>>>>> On 5/25/2023 6:16 AM, Ben Bacarisse wrote:
>>>>>> Fritz Feldhase <franz.fritschee.ff@gmail.com> writes:
>>>>>>
>>>>>>> On Wednesday, May 24, 2023 at 9:14:36 PM UTC+2, Richard Damon wrote:
>>>>>>>
>>>>>>> Following pseudocode for D:
>>>>>>>
>>>>>>> arbitrarily long int D(int start) {
>>>>>>>
>>>>>>>          arbitrarily long int n = start
>>>>>>>          while (n is not a perfect number) {
>>>>>>>          n = n + 2
>>>>>>>          }
>>>>>>>
>>>>>>>          return n
>>>>>>> }
>>>>>>>
>>>>>>> What would Olcott's "simulating halt decider" return (answer) if
>>>>>>> called with, say, H(D, 1)?
>>>>>>
>>>>>> Why would you care?  PO's H returns "does not halt" for at least some
>>>>>> halting computations (citations available on request) so the result
>>>>>> tells you nothing of interest.
>>>>>>
>>>>>> PO equivocates over whether he is concerned about just the one
>>>>>> case used
>>>>>> in the usual proof's construction or the general case, but
>>>>>> regardless of
>>>>>> what side of that fence he is currently sitting, you can't use his
>>>>>> H for
>>>>>> anything useful.
>>>>>>
>>>>>>> How would it know the correct answer? Will it ever return an answer?
>>>>>>> (Especially, _if_ there is no odd perfect number?)
>>>>>>
>>>>>> On some days he will claim that he has never said he has a general
>>>>>> halt
>>>>>> decider, just one that can't be fooled by the "usual
>>>>>> construction".  It
>>>>>> "can't be fooled" because he simply declares that H(H^, H^) ==
>>>>>> false is
>>>>>> the correct answer "even though" H^(H^) halts.
>>>>>>
>>>>>> On other days, he throws caution to the wind and claims the general
>>>>>> case, but again with the set of non-halting computations
>>>>>> "augmented" by
>>>>>> some unspecified set of halting ones.
>>>>>>
>>>>>> Of course, he is also not an honest disputant, because he will avoid
>>>>>> giving a direct answer to a simple question for years (literally
>>>>>> years),
>>>>>> and he will even say contradictory things days apart (again,
>>>>>> citations
>>>>>> available on request) so it can take some time to clear all the smoke
>>>>>> from the mirrors.  But once he has said
>>>>>>
>>>>>>    "Yes that is the correct answer even though P(P) halts."
>>>>>>
>>>>>> in reply to the question "do you still assert that H(P,P) == false is
>>>>>> the 'correct' answer even though P(P) halts?" I don't see any
>>>>>> point in
>>>>>> carrying on, or at least I see not point in saying anything else.
>>>>>>
>>>>>> The one weapon we have against cranks is that most can't bear to
>>>>>> retract
>>>>>> any substantive claim.  This is why they are usually so evasive about
>>>>>> giving direct answers -- they know they will have to stick with them.
>>>>>> But once they have made the mistake of being clear, we should pay
>>>>>> them
>>>>>> the courtesy of quoting them at every available opportunity.
>>>>>>
>>>>>
>>>>> Ben has already agreed that H does correctly determine that halt
>>>>> status
>>>>> of its input according to the Sipser approved criteria. (see quote
>>>>> below) The Sipser approved criteria is a tautology thus necessarily
>>>>> true.
>>>>>
>>>>
>>>> Nope, you MIS-QUOTE him by removing context, which is just a form of
>>>> LYING.
>>>>
>>>
>>> The context does not change the fact that he agreed that H does
>>> correctly determine the halt status of D according to the Sisper
>>> approved criteria.
>>>
>>>>> Because all deciders only compute the mapping *from their inputs* to
>>>>> their own accept or reject state and the only objection to my proof is
>>>>> that it does not get the same result as a non-input this only
>>>>> objection
>>>>> is nullified. *My proof is correct by tautology*
>>>>
>>>> SO, what mapping is this supposed to compute, if this is what ALL
>>>> decider do, is "Halting" the only type of decider?
>>>>
>>>> Remember, Halting is DEFINED as the MACHINE coming to a final state,
>>>> and it does.
>>>>
>>>>>
>>>>> My reviewers insist on staying one recursive invocation away from
>>>>> reality. H does correctly determine that D correctly simulated by H
>>>>> cannot possibly terminate normally.
>>>>
>>>> Except YOU are one invocation from the probem. It isn't asking about
>>>> the simulatiion done by H, but by the machine that H is TRYING to
>>>> simulate (but can't).
>>>>
>>>>>
>>>>> My reviewers only focus on the behavior after H has already made this
>>>>> correct halt status decision, thus are clearly out-of-sync by one
>>>>> recursive invocation.
>>>>
>>>> Because it makes the WRONG decision by the definition of the
>>>> problem, what does the machine represented by the input do?
>>>>
>>>
>>> The definition of the problem that you are referring to contradicts
>>> the definition of a decider that must compute the mapping from
>>> AN INPUT
>>> AN INPUT
>>> AN INPUT
>>> AN INPUT
>>> AN INPUT
>>> AN INPUT
>>> AN INPUT
>>> AN INPUT
>>> AN INPUT
>>> to an its own accept or reject state.
>>>
>>> You think that H is wrong because the outer invocation halts only
>>> because the inner invocation was correctly aborted.
>>>
>>> You know that it is necessarily true that no invocation would ever halt
>>> unless the inner invocation was aborted, thus making the termination of
>>> this inner invocation necessarily correct.
>>>
>>
>> I have better words. The termination of the simulation of D is mandated
>> by the requirements that a halt decider must always halt, thus
>> conclusively proving that this termination is necessarily correct.
>>
>
> It is also mandated to give the correct answer, which since H(D,D)
> returns 0, which causes D(D) to Halt, the only correct answer that
> H(D,D) should give is 1, so it is necessarily incorrect.

The easily verified fact that H itself would not terminate unless it
aborted the simulation of its input conclusively proves that H is
necessarily correct to do this and report this input as non-halting.

This equally applies to the Peter Linz Turing machine based halting
problem proof with embedded_H and ⟨Ĥ⟩.

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

On 5/25/23 10:26 PM, olcott wrote:
> On 5/25/2023 8:56 PM, Richard Damon wrote:
>> On 5/25/23 9:43 PM, olcott wrote:
>>> On 5/25/2023 8:29 PM, olcott wrote:
>>>> On 5/25/2023 7:01 PM, Richard Damon wrote:
>>>>> On 5/25/23 11:30 AM, olcott wrote:
>>>>>> On 5/25/2023 6:16 AM, Ben Bacarisse wrote:
>>>>>>> Fritz Feldhase <franz.fritschee.ff@gmail.com> writes:
>>>>>>>
>>>>>>>> On Wednesday, May 24, 2023 at 9:14:36 PM UTC+2, Richard Damon
>>>>>>>> wrote:
>>>>>>>>
>>>>>>>> Following pseudocode for D:
>>>>>>>>
>>>>>>>> arbitrarily long int D(int start) {
>>>>>>>>
>>>>>>>>          arbitrarily long int n = start
>>>>>>>>          while (n is not a perfect number) {
>>>>>>>>          n = n + 2
>>>>>>>>          }
>>>>>>>>
>>>>>>>>          return n
>>>>>>>> }
>>>>>>>>
>>>>>>>> What would Olcott's "simulating halt decider" return (answer) if
>>>>>>>> called with, say, H(D, 1)?
>>>>>>>
>>>>>>> Why would you care?  PO's H returns "does not halt" for at least
>>>>>>> some
>>>>>>> halting computations (citations available on request) so the result
>>>>>>> tells you nothing of interest.
>>>>>>>
>>>>>>> PO equivocates over whether he is concerned about just the one
>>>>>>> case used
>>>>>>> in the usual proof's construction or the general case, but
>>>>>>> regardless of
>>>>>>> what side of that fence he is currently sitting, you can't use
>>>>>>> his H for
>>>>>>> anything useful.
>>>>>>>
>>>>>>>> How would it know the correct answer? Will it ever return an
>>>>>>>> answer?
>>>>>>>> (Especially, _if_ there is no odd perfect number?)
>>>>>>>
>>>>>>> On some days he will claim that he has never said he has a
>>>>>>> general halt
>>>>>>> decider, just one that can't be fooled by the "usual
>>>>>>> construction".  It
>>>>>>> "can't be fooled" because he simply declares that H(H^, H^) ==
>>>>>>> false is
>>>>>>> the correct answer "even though" H^(H^) halts.
>>>>>>>
>>>>>>> On other days, he throws caution to the wind and claims the general
>>>>>>> case, but again with the set of non-halting computations
>>>>>>> "augmented" by
>>>>>>> some unspecified set of halting ones.
>>>>>>>
>>>>>>> Of course, he is also not an honest disputant, because he will avoid
>>>>>>> giving a direct answer to a simple question for years (literally
>>>>>>> years),
>>>>>>> and he will even say contradictory things days apart (again,
>>>>>>> citations
>>>>>>> available on request) so it can take some time to clear all the
>>>>>>> smoke
>>>>>>> from the mirrors.  But once he has said
>>>>>>>
>>>>>>>    "Yes that is the correct answer even though P(P) halts."
>>>>>>>
>>>>>>> in reply to the question "do you still assert that H(P,P) ==
>>>>>>> false is
>>>>>>> the 'correct' answer even though P(P) halts?" I don't see any
>>>>>>> point in
>>>>>>> carrying on, or at least I see not point in saying anything else.
>>>>>>>
>>>>>>> The one weapon we have against cranks is that most can't bear to
>>>>>>> retract
>>>>>>> any substantive claim.  This is why they are usually so evasive
>>>>>>> about
>>>>>>> giving direct answers -- they know they will have to stick with
>>>>>>> them.
>>>>>>> But once they have made the mistake of being clear, we should pay
>>>>>>> them
>>>>>>> the courtesy of quoting them at every available opportunity.
>>>>>>>
>>>>>>
>>>>>> Ben has already agreed that H does correctly determine that halt
>>>>>> status
>>>>>> of its input according to the Sipser approved criteria. (see quote
>>>>>> below) The Sipser approved criteria is a tautology thus necessarily
>>>>>> true.
>>>>>>
>>>>>
>>>>> Nope, you MIS-QUOTE him by removing context, which is just a form
>>>>> of LYING.
>>>>>
>>>>
>>>> The context does not change the fact that he agreed that H does
>>>> correctly determine the halt status of D according to the Sisper
>>>> approved criteria.
>>>>
>>>>>> Because all deciders only compute the mapping *from their inputs* to
>>>>>> their own accept or reject state and the only objection to my
>>>>>> proof is
>>>>>> that it does not get the same result as a non-input this only
>>>>>> objection
>>>>>> is nullified. *My proof is correct by tautology*
>>>>>
>>>>> SO, what mapping is this supposed to compute, if this is what ALL
>>>>> decider do, is "Halting" the only type of decider?
>>>>>
>>>>> Remember, Halting is DEFINED as the MACHINE coming to a final
>>>>> state, and it does.
>>>>>
>>>>>>
>>>>>> My reviewers insist on staying one recursive invocation away from
>>>>>> reality. H does correctly determine that D correctly simulated by H
>>>>>> cannot possibly terminate normally.
>>>>>
>>>>> Except YOU are one invocation from the probem. It isn't asking
>>>>> about the simulatiion done by H, but by the machine that H is
>>>>> TRYING to simulate (but can't).
>>>>>
>>>>>>
>>>>>> My reviewers only focus on the behavior after H has already made this
>>>>>> correct halt status decision, thus are clearly out-of-sync by one
>>>>>> recursive invocation.
>>>>>
>>>>> Because it makes the WRONG decision by the definition of the
>>>>> problem, what does the machine represented by the input do?
>>>>>
>>>>
>>>> The definition of the problem that you are referring to contradicts
>>>> the definition of a decider that must compute the mapping from
>>>> AN INPUT
>>>> AN INPUT
>>>> AN INPUT
>>>> AN INPUT
>>>> AN INPUT
>>>> AN INPUT
>>>> AN INPUT
>>>> AN INPUT
>>>> AN INPUT
>>>> to an its own accept or reject state.
>>>>
>>>> You think that H is wrong because the outer invocation halts only
>>>> because the inner invocation was correctly aborted.
>>>>
>>>> You know that it is necessarily true that no invocation would ever halt
>>>> unless the inner invocation was aborted, thus making the termination of
>>>> this inner invocation necessarily correct.
>>>>
>>>
>>> I have better words. The termination of the simulation of D is mandated
>>> by the requirements that a halt decider must always halt, thus
>>> conclusively proving that this termination is necessarily correct.
>>>
>>
>> It is also mandated to give the correct answer, which since H(D,D)
>> returns 0, which causes D(D) to Halt, the only correct answer that
>> H(D,D) should give is 1, so it is necessarily incorrect.
>
> The easily verified fact that H itself would not terminate unless it
> aborted the simulation of its input conclusively proves that H is
> necessarily correct to do this and report this input as non-halting.
>
> This equally applies to the Peter Linz Turing machine based halting
> problem proof with embedded_H and ⟨Ĥ⟩.
>

On 5/25/2023 9:42 PM, Richard Damon wrote:
> On 5/25/23 10:26 PM, olcott wrote:
>> On 5/25/2023 8:56 PM, Richard Damon wrote:
>>> On 5/25/23 9:43 PM, olcott wrote:
>>>> On 5/25/2023 8:29 PM, olcott wrote:
>>>>> On 5/25/2023 7:01 PM, Richard Damon wrote:
>>>>>> On 5/25/23 11:30 AM, olcott wrote:
>>>>>>> On 5/25/2023 6:16 AM, Ben Bacarisse wrote:
>>>>>>>> Fritz Feldhase <franz.fritschee.ff@gmail.com> writes:
>>>>>>>>
>>>>>>>>> On Wednesday, May 24, 2023 at 9:14:36 PM UTC+2, Richard Damon
>>>>>>>>> wrote:
>>>>>>>>>
>>>>>>>>> Following pseudocode for D:
>>>>>>>>>
>>>>>>>>> arbitrarily long int D(int start) {
>>>>>>>>>
>>>>>>>>>          arbitrarily long int n = start
>>>>>>>>>          while (n is not a perfect number) {
>>>>>>>>>          n = n + 2
>>>>>>>>>          }
>>>>>>>>>
>>>>>>>>>          return n
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> What would Olcott's "simulating halt decider" return (answer) if
>>>>>>>>> called with, say, H(D, 1)?
>>>>>>>>
>>>>>>>> Why would you care?  PO's H returns "does not halt" for at least
>>>>>>>> some
>>>>>>>> halting computations (citations available on request) so the result
>>>>>>>> tells you nothing of interest.
>>>>>>>>
>>>>>>>> PO equivocates over whether he is concerned about just the one
>>>>>>>> case used
>>>>>>>> in the usual proof's construction or the general case, but
>>>>>>>> regardless of
>>>>>>>> what side of that fence he is currently sitting, you can't use
>>>>>>>> his H for
>>>>>>>> anything useful.
>>>>>>>>
>>>>>>>>> How would it know the correct answer? Will it ever return an
>>>>>>>>> answer?
>>>>>>>>> (Especially, _if_ there is no odd perfect number?)
>>>>>>>>
>>>>>>>> On some days he will claim that he has never said he has a
>>>>>>>> general halt
>>>>>>>> decider, just one that can't be fooled by the "usual
>>>>>>>> construction".  It
>>>>>>>> "can't be fooled" because he simply declares that H(H^, H^) ==
>>>>>>>> false is
>>>>>>>> the correct answer "even though" H^(H^) halts.
>>>>>>>>
>>>>>>>> On other days, he throws caution to the wind and claims the general
>>>>>>>> case, but again with the set of non-halting computations
>>>>>>>> "augmented" by
>>>>>>>> some unspecified set of halting ones.
>>>>>>>>
>>>>>>>> Of course, he is also not an honest disputant, because he will
>>>>>>>> avoid
>>>>>>>> giving a direct answer to a simple question for years (literally
>>>>>>>> years),
>>>>>>>> and he will even say contradictory things days apart (again,
>>>>>>>> citations
>>>>>>>> available on request) so it can take some time to clear all the
>>>>>>>> smoke
>>>>>>>> from the mirrors.  But once he has said
>>>>>>>>
>>>>>>>>    "Yes that is the correct answer even though P(P) halts."
>>>>>>>>
>>>>>>>> in reply to the question "do you still assert that H(P,P) ==
>>>>>>>> false is
>>>>>>>> the 'correct' answer even though P(P) halts?" I don't see any
>>>>>>>> point in
>>>>>>>> carrying on, or at least I see not point in saying anything else.
>>>>>>>>
>>>>>>>> The one weapon we have against cranks is that most can't bear to
>>>>>>>> retract
>>>>>>>> any substantive claim.  This is why they are usually so evasive
>>>>>>>> about
>>>>>>>> giving direct answers -- they know they will have to stick with
>>>>>>>> them.
>>>>>>>> But once they have made the mistake of being clear, we should
>>>>>>>> pay them
>>>>>>>> the courtesy of quoting them at every available opportunity.
>>>>>>>>
>>>>>>>
>>>>>>> Ben has already agreed that H does correctly determine that halt
>>>>>>> status
>>>>>>> of its input according to the Sipser approved criteria. (see quote
>>>>>>> below) The Sipser approved criteria is a tautology thus necessarily
>>>>>>> true.
>>>>>>>
>>>>>>
>>>>>> Nope, you MIS-QUOTE him by removing context, which is just a form
>>>>>> of LYING.
>>>>>>
>>>>>
>>>>> The context does not change the fact that he agreed that H does
>>>>> correctly determine the halt status of D according to the Sisper
>>>>> approved criteria.
>>>>>
>>>>>>> Because all deciders only compute the mapping *from their inputs* to
>>>>>>> their own accept or reject state and the only objection to my
>>>>>>> proof is
>>>>>>> that it does not get the same result as a non-input this only
>>>>>>> objection
>>>>>>> is nullified. *My proof is correct by tautology*
>>>>>>
>>>>>> SO, what mapping is this supposed to compute, if this is what ALL
>>>>>> decider do, is "Halting" the only type of decider?
>>>>>>
>>>>>> Remember, Halting is DEFINED as the MACHINE coming to a final
>>>>>> state, and it does.
>>>>>>
>>>>>>>
>>>>>>> My reviewers insist on staying one recursive invocation away from
>>>>>>> reality. H does correctly determine that D correctly simulated by H
>>>>>>> cannot possibly terminate normally.
>>>>>>
>>>>>> Except YOU are one invocation from the probem. It isn't asking
>>>>>> about the simulatiion done by H, but by the machine that H is
>>>>>> TRYING to simulate (but can't).
>>>>>>
>>>>>>>
>>>>>>> My reviewers only focus on the behavior after H has already made
>>>>>>> this
>>>>>>> correct halt status decision, thus are clearly out-of-sync by one
>>>>>>> recursive invocation.
>>>>>>
>>>>>> Because it makes the WRONG decision by the definition of the
>>>>>> problem, what does the machine represented by the input do?
>>>>>>
>>>>>
>>>>> The definition of the problem that you are referring to contradicts
>>>>> the definition of a decider that must compute the mapping from
>>>>> AN INPUT
>>>>> AN INPUT
>>>>> AN INPUT
>>>>> AN INPUT
>>>>> AN INPUT
>>>>> AN INPUT
>>>>> AN INPUT
>>>>> AN INPUT
>>>>> AN INPUT
>>>>> to an its own accept or reject state.
>>>>>
>>>>> You think that H is wrong because the outer invocation halts only
>>>>> because the inner invocation was correctly aborted.
>>>>>
>>>>> You know that it is necessarily true that no invocation would ever
>>>>> halt
>>>>> unless the inner invocation was aborted, thus making the
>>>>> termination of
>>>>> this inner invocation necessarily correct.
>>>>>
>>>>
>>>> I have better words. The termination of the simulation of D is mandated
>>>> by the requirements that a halt decider must always halt, thus
>>>> conclusively proving that this termination is necessarily correct.
>>>>
>>>
>>> It is also mandated to give the correct answer, which since H(D,D)
>>> returns 0, which causes D(D) to Halt, the only correct answer that
>>> H(D,D) should give is 1, so it is necessarily incorrect.
>>
>> The easily verified fact that H itself would not terminate unless it
>> aborted the simulation of its input conclusively proves that H is
>> necessarily correct to do this and report this input as non-halting.
>>
>> This equally applies to the Peter Linz Turing machine based halting
>> problem proof with embedded_H and ⟨Ĥ⟩.
>>
>
> So? H not terminating is its own problem.
Since it is required to terminate the choice to not abort its simulation
would violate this requirement thus making this choice necessarily
correct. This also conclusively proves that its input cannot possibly
terminate normally thus is correctly determined to be non-halting.

On 5/25/23 10:55 PM, olcott wrote:
> On 5/25/2023 9:42 PM, Richard Damon wrote:
>> On 5/25/23 10:26 PM, olcott wrote:
>>> On 5/25/2023 8:56 PM, Richard Damon wrote:
>>>> On 5/25/23 9:43 PM, olcott wrote:
>>>>> On 5/25/2023 8:29 PM, olcott wrote:
>>>>>> On 5/25/2023 7:01 PM, Richard Damon wrote:
>>>>>>> On 5/25/23 11:30 AM, olcott wrote:
>>>>>>>> On 5/25/2023 6:16 AM, Ben Bacarisse wrote:
>>>>>>>>> Fritz Feldhase <franz.fritschee.ff@gmail.com> writes:
>>>>>>>>>
>>>>>>>>>> On Wednesday, May 24, 2023 at 9:14:36 PM UTC+2, Richard Damon
>>>>>>>>>> wrote:
>>>>>>>>>>
>>>>>>>>>> Following pseudocode for D:
>>>>>>>>>>
>>>>>>>>>> arbitrarily long int D(int start) {
>>>>>>>>>>
>>>>>>>>>>          arbitrarily long int n = start
>>>>>>>>>>          while (n is not a perfect number) {
>>>>>>>>>>          n = n + 2
>>>>>>>>>>          }
>>>>>>>>>>
>>>>>>>>>>          return n
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> What would Olcott's "simulating halt decider" return (answer) if
>>>>>>>>>> called with, say, H(D, 1)?
>>>>>>>>>
>>>>>>>>> Why would you care?  PO's H returns "does not halt" for at
>>>>>>>>> least some
>>>>>>>>> halting computations (citations available on request) so the
>>>>>>>>> result
>>>>>>>>> tells you nothing of interest.
>>>>>>>>>
>>>>>>>>> PO equivocates over whether he is concerned about just the one
>>>>>>>>> case used
>>>>>>>>> in the usual proof's construction or the general case, but
>>>>>>>>> regardless of
>>>>>>>>> what side of that fence he is currently sitting, you can't use
>>>>>>>>> his H for
>>>>>>>>> anything useful.
>>>>>>>>>
>>>>>>>>>> How would it know the correct answer? Will it ever return an
>>>>>>>>>> answer?
>>>>>>>>>> (Especially, _if_ there is no odd perfect number?)
>>>>>>>>>
>>>>>>>>> On some days he will claim that he has never said he has a
>>>>>>>>> general halt
>>>>>>>>> decider, just one that can't be fooled by the "usual
>>>>>>>>> construction".  It
>>>>>>>>> "can't be fooled" because he simply declares that H(H^, H^) ==
>>>>>>>>> false is
>>>>>>>>> the correct answer "even though" H^(H^) halts.
>>>>>>>>>
>>>>>>>>> On other days, he throws caution to the wind and claims the
>>>>>>>>> general
>>>>>>>>> case, but again with the set of non-halting computations
>>>>>>>>> "augmented" by
>>>>>>>>> some unspecified set of halting ones.
>>>>>>>>>
>>>>>>>>> Of course, he is also not an honest disputant, because he will
>>>>>>>>> avoid
>>>>>>>>> giving a direct answer to a simple question for years
>>>>>>>>> (literally years),
>>>>>>>>> and he will even say contradictory things days apart (again,
>>>>>>>>> citations
>>>>>>>>> available on request) so it can take some time to clear all the
>>>>>>>>> smoke
>>>>>>>>> from the mirrors.  But once he has said
>>>>>>>>>
>>>>>>>>>    "Yes that is the correct answer even though P(P) halts."
>>>>>>>>>
>>>>>>>>> in reply to the question "do you still assert that H(P,P) ==
>>>>>>>>> false is
>>>>>>>>> the 'correct' answer even though P(P) halts?" I don't see any
>>>>>>>>> point in
>>>>>>>>> carrying on, or at least I see not point in saying anything else.
>>>>>>>>>
>>>>>>>>> The one weapon we have against cranks is that most can't bear
>>>>>>>>> to retract
>>>>>>>>> any substantive claim.  This is why they are usually so evasive
>>>>>>>>> about
>>>>>>>>> giving direct answers -- they know they will have to stick with
>>>>>>>>> them.
>>>>>>>>> But once they have made the mistake of being clear, we should
>>>>>>>>> pay them
>>>>>>>>> the courtesy of quoting them at every available opportunity.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Ben has already agreed that H does correctly determine that halt
>>>>>>>> status
>>>>>>>> of its input according to the Sipser approved criteria. (see quote
>>>>>>>> below) The Sipser approved criteria is a tautology thus necessarily
>>>>>>>> true.
>>>>>>>>
>>>>>>>
>>>>>>> Nope, you MIS-QUOTE him by removing context, which is just a form
>>>>>>> of LYING.
>>>>>>>
>>>>>>
>>>>>> The context does not change the fact that he agreed that H does
>>>>>> correctly determine the halt status of D according to the Sisper
>>>>>> approved criteria.
>>>>>>
>>>>>>>> Because all deciders only compute the mapping *from their
>>>>>>>> inputs* to
>>>>>>>> their own accept or reject state and the only objection to my
>>>>>>>> proof is
>>>>>>>> that it does not get the same result as a non-input this only
>>>>>>>> objection
>>>>>>>> is nullified. *My proof is correct by tautology*
>>>>>>>
>>>>>>> SO, what mapping is this supposed to compute, if this is what ALL
>>>>>>> decider do, is "Halting" the only type of decider?
>>>>>>>
>>>>>>> Remember, Halting is DEFINED as the MACHINE coming to a final
>>>>>>> state, and it does.
>>>>>>>
>>>>>>>>
>>>>>>>> My reviewers insist on staying one recursive invocation away from
>>>>>>>> reality. H does correctly determine that D correctly simulated by H
>>>>>>>> cannot possibly terminate normally.
>>>>>>>
>>>>>>> Except YOU are one invocation from the probem. It isn't asking
>>>>>>> about the simulatiion done by H, but by the machine that H is
>>>>>>> TRYING to simulate (but can't).
>>>>>>>
>>>>>>>>
>>>>>>>> My reviewers only focus on the behavior after H has already made
>>>>>>>> this
>>>>>>>> correct halt status decision, thus are clearly out-of-sync by one
>>>>>>>> recursive invocation.
>>>>>>>
>>>>>>> Because it makes the WRONG decision by the definition of the
>>>>>>> problem, what does the machine represented by the input do?
>>>>>>>
>>>>>>
>>>>>> The definition of the problem that you are referring to
>>>>>> contradicts the definition of a decider that must compute the
>>>>>> mapping from
>>>>>> AN INPUT
>>>>>> AN INPUT
>>>>>> AN INPUT
>>>>>> AN INPUT
>>>>>> AN INPUT
>>>>>> AN INPUT
>>>>>> AN INPUT
>>>>>> AN INPUT
>>>>>> AN INPUT
>>>>>> to an its own accept or reject state.
>>>>>>
>>>>>> You think that H is wrong because the outer invocation halts only
>>>>>> because the inner invocation was correctly aborted.
>>>>>>
>>>>>> You know that it is necessarily true that no invocation would ever
>>>>>> halt
>>>>>> unless the inner invocation was aborted, thus making the
>>>>>> termination of
>>>>>> this inner invocation necessarily correct.
>>>>>>
>>>>>
>>>>> I have better words. The termination of the simulation of D is
>>>>> mandated
>>>>> by the requirements that a halt decider must always halt, thus
>>>>> conclusively proving that this termination is necessarily correct.
>>>>>
>>>>
>>>> It is also mandated to give the correct answer, which since H(D,D)
>>>> returns 0, which causes D(D) to Halt, the only correct answer that
>>>> H(D,D) should give is 1, so it is necessarily incorrect.
>>>
>>> The easily verified fact that H itself would not terminate unless it
>>> aborted the simulation of its input conclusively proves that H is
>>> necessarily correct to do this and report this input as non-halting.
>>>
>>> This equally applies to the Peter Linz Turing machine based halting
>>> problem proof with embedded_H and ⟨Ĥ⟩.
>>>
>>
>> So? H not terminating is its own problem.
> Since it is required to terminate the choice to not abort its simulation
> would violate this requirement thus making this choice necessarily
> correct. This also conclusively proves that its input cannot possibly
> terminate normally thus is correctly determined to be non-halting.
>

On 5/25/2023 10:10 PM, Richard Damon wrote:
> On 5/25/23 10:55 PM, olcott wrote:
>> On 5/25/2023 9:42 PM, Richard Damon wrote:
>>> On 5/25/23 10:26 PM, olcott wrote:
>>>> On 5/25/2023 8:56 PM, Richard Damon wrote:
>>>>> On 5/25/23 9:43 PM, olcott wrote:
>>>>>> On 5/25/2023 8:29 PM, olcott wrote:
>>>>>>> On 5/25/2023 7:01 PM, Richard Damon wrote:
>>>>>>>> On 5/25/23 11:30 AM, olcott wrote:
>>>>>>>>> On 5/25/2023 6:16 AM, Ben Bacarisse wrote:
>>>>>>>>>> Fritz Feldhase <franz.fritschee.ff@gmail.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On Wednesday, May 24, 2023 at 9:14:36 PM UTC+2, Richard Damon
>>>>>>>>>>> wrote:
>>>>>>>>>>>
>>>>>>>>>>> Following pseudocode for D:
>>>>>>>>>>>
>>>>>>>>>>> arbitrarily long int D(int start) {
>>>>>>>>>>>
>>>>>>>>>>>          arbitrarily long int n = start
>>>>>>>>>>>          while (n is not a perfect number) {
>>>>>>>>>>>          n = n + 2
>>>>>>>>>>>          }
>>>>>>>>>>>
>>>>>>>>>>>          return n
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> What would Olcott's "simulating halt decider" return (answer) if
>>>>>>>>>>> called with, say, H(D, 1)?
>>>>>>>>>>
>>>>>>>>>> Why would you care?  PO's H returns "does not halt" for at
>>>>>>>>>> least some
>>>>>>>>>> halting computations (citations available on request) so the
>>>>>>>>>> result
>>>>>>>>>> tells you nothing of interest.
>>>>>>>>>>
>>>>>>>>>> PO equivocates over whether he is concerned about just the one
>>>>>>>>>> case used
>>>>>>>>>> in the usual proof's construction or the general case, but
>>>>>>>>>> regardless of
>>>>>>>>>> what side of that fence he is currently sitting, you can't use
>>>>>>>>>> his H for
>>>>>>>>>> anything useful.
>>>>>>>>>>
>>>>>>>>>>> How would it know the correct answer? Will it ever return an
>>>>>>>>>>> answer?
>>>>>>>>>>> (Especially, _if_ there is no odd perfect number?)
>>>>>>>>>>
>>>>>>>>>> On some days he will claim that he has never said he has a
>>>>>>>>>> general halt
>>>>>>>>>> decider, just one that can't be fooled by the "usual
>>>>>>>>>> construction".  It
>>>>>>>>>> "can't be fooled" because he simply declares that H(H^, H^) ==
>>>>>>>>>> false is
>>>>>>>>>> the correct answer "even though" H^(H^) halts.
>>>>>>>>>>
>>>>>>>>>> On other days, he throws caution to the wind and claims the
>>>>>>>>>> general
>>>>>>>>>> case, but again with the set of non-halting computations
>>>>>>>>>> "augmented" by
>>>>>>>>>> some unspecified set of halting ones.
>>>>>>>>>>
>>>>>>>>>> Of course, he is also not an honest disputant, because he will
>>>>>>>>>> avoid
>>>>>>>>>> giving a direct answer to a simple question for years
>>>>>>>>>> (literally years),
>>>>>>>>>> and he will even say contradictory things days apart (again,
>>>>>>>>>> citations
>>>>>>>>>> available on request) so it can take some time to clear all
>>>>>>>>>> the smoke
>>>>>>>>>> from the mirrors.  But once he has said
>>>>>>>>>>
>>>>>>>>>>    "Yes that is the correct answer even though P(P) halts."
>>>>>>>>>>
>>>>>>>>>> in reply to the question "do you still assert that H(P,P) ==
>>>>>>>>>> false is
>>>>>>>>>> the 'correct' answer even though P(P) halts?" I don't see any
>>>>>>>>>> point in
>>>>>>>>>> carrying on, or at least I see not point in saying anything else.
>>>>>>>>>>
>>>>>>>>>> The one weapon we have against cranks is that most can't bear
>>>>>>>>>> to retract
>>>>>>>>>> any substantive claim.  This is why they are usually so
>>>>>>>>>> evasive about
>>>>>>>>>> giving direct answers -- they know they will have to stick
>>>>>>>>>> with them.
>>>>>>>>>> But once they have made the mistake of being clear, we should
>>>>>>>>>> pay them
>>>>>>>>>> the courtesy of quoting them at every available opportunity.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Ben has already agreed that H does correctly determine that
>>>>>>>>> halt status
>>>>>>>>> of its input according to the Sipser approved criteria. (see quote
>>>>>>>>> below) The Sipser approved criteria is a tautology thus
>>>>>>>>> necessarily
>>>>>>>>> true.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Nope, you MIS-QUOTE him by removing context, which is just a
>>>>>>>> form of LYING.
>>>>>>>>
>>>>>>>
>>>>>>> The context does not change the fact that he agreed that H does
>>>>>>> correctly determine the halt status of D according to the Sisper
>>>>>>> approved criteria.
>>>>>>>
>>>>>>>>> Because all deciders only compute the mapping *from their
>>>>>>>>> inputs* to
>>>>>>>>> their own accept or reject state and the only objection to my
>>>>>>>>> proof is
>>>>>>>>> that it does not get the same result as a non-input this only
>>>>>>>>> objection
>>>>>>>>> is nullified. *My proof is correct by tautology*
>>>>>>>>
>>>>>>>> SO, what mapping is this supposed to compute, if this is what
>>>>>>>> ALL decider do, is "Halting" the only type of decider?
>>>>>>>>
>>>>>>>> Remember, Halting is DEFINED as the MACHINE coming to a final
>>>>>>>> state, and it does.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> My reviewers insist on staying one recursive invocation away from
>>>>>>>>> reality. H does correctly determine that D correctly simulated
>>>>>>>>> by H
>>>>>>>>> cannot possibly terminate normally.
>>>>>>>>
>>>>>>>> Except YOU are one invocation from the probem. It isn't asking
>>>>>>>> about the simulatiion done by H, but by the machine that H is
>>>>>>>> TRYING to simulate (but can't).
>>>>>>>>
>>>>>>>>>
>>>>>>>>> My reviewers only focus on the behavior after H has already
>>>>>>>>> made this
>>>>>>>>> correct halt status decision, thus are clearly out-of-sync by one
>>>>>>>>> recursive invocation.
>>>>>>>>
>>>>>>>> Because it makes the WRONG decision by the definition of the
>>>>>>>> problem, what does the machine represented by the input do?
>>>>>>>>
>>>>>>>
>>>>>>> The definition of the problem that you are referring to
>>>>>>> contradicts the definition of a decider that must compute the
>>>>>>> mapping from
>>>>>>> AN INPUT
>>>>>>> AN INPUT
>>>>>>> AN INPUT
>>>>>>> AN INPUT
>>>>>>> AN INPUT
>>>>>>> AN INPUT
>>>>>>> AN INPUT
>>>>>>> AN INPUT
>>>>>>> AN INPUT
>>>>>>> to an its own accept or reject state.
>>>>>>>
>>>>>>> You think that H is wrong because the outer invocation halts only
>>>>>>> because the inner invocation was correctly aborted.
>>>>>>>
>>>>>>> You know that it is necessarily true that no invocation would
>>>>>>> ever halt
>>>>>>> unless the inner invocation was aborted, thus making the
>>>>>>> termination of
>>>>>>> this inner invocation necessarily correct.
>>>>>>>
>>>>>>
>>>>>> I have better words. The termination of the simulation of D is
>>>>>> mandated
>>>>>> by the requirements that a halt decider must always halt, thus
>>>>>> conclusively proving that this termination is necessarily correct.
>>>>>>
>>>>>
>>>>> It is also mandated to give the correct answer, which since H(D,D)
>>>>> returns 0, which causes D(D) to Halt, the only correct answer that
>>>>> H(D,D) should give is 1, so it is necessarily incorrect.
>>>>
>>>> The easily verified fact that H itself would not terminate unless it
>>>> aborted the simulation of its input conclusively proves that H is
>>>> necessarily correct to do this and report this input as non-halting.
>>>>
>>>> This equally applies to the Peter Linz Turing machine based halting
>>>> problem proof with embedded_H and ⟨Ĥ⟩.
>>>>
>>>
>>> So? H not terminating is its own problem.
>> Since it is required to terminate the choice to not abort its simulation
>> would violate this requirement thus making this choice necessarily
>> correct. This also conclusively proves that its input cannot possibly
>> terminate normally thus is correctly determined to be non-halting.
>>
>
> So? You still don't get it.
>
> yes, it is required to give an answer in finite time, so it can't just
> be programmed to simulate forever. It also is required to return the
> correct answer,
Since it is true that unless H aborts its simulation of D that H itself
never terminates normally that makes it necessarily correct to do this.

On 5/25/23 11:17 PM, olcott wrote:
> On 5/25/2023 10:10 PM, Richard Damon wrote:
>> On 5/25/23 10:55 PM, olcott wrote:
>>> On 5/25/2023 9:42 PM, Richard Damon wrote:
>>>> On 5/25/23 10:26 PM, olcott wrote:
>>>>> On 5/25/2023 8:56 PM, Richard Damon wrote:
>>>>>> On 5/25/23 9:43 PM, olcott wrote:
>>>>>>> On 5/25/2023 8:29 PM, olcott wrote:
>>>>>>>> On 5/25/2023 7:01 PM, Richard Damon wrote:
>>>>>>>>> On 5/25/23 11:30 AM, olcott wrote:
>>>>>>>>>> On 5/25/2023 6:16 AM, Ben Bacarisse wrote:
>>>>>>>>>>> Fritz Feldhase <franz.fritschee.ff@gmail.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On Wednesday, May 24, 2023 at 9:14:36 PM UTC+2, Richard
>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> Following pseudocode for D:
>>>>>>>>>>>>
>>>>>>>>>>>> arbitrarily long int D(int start) {
>>>>>>>>>>>>
>>>>>>>>>>>>          arbitrarily long int n = start
>>>>>>>>>>>>          while (n is not a perfect number) {
>>>>>>>>>>>>          n = n + 2
>>>>>>>>>>>>          }
>>>>>>>>>>>>
>>>>>>>>>>>>          return n
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> What would Olcott's "simulating halt decider" return
>>>>>>>>>>>> (answer) if
>>>>>>>>>>>> called with, say, H(D, 1)?
>>>>>>>>>>>
>>>>>>>>>>> Why would you care?  PO's H returns "does not halt" for at
>>>>>>>>>>> least some
>>>>>>>>>>> halting computations (citations available on request) so the
>>>>>>>>>>> result
>>>>>>>>>>> tells you nothing of interest.
>>>>>>>>>>>
>>>>>>>>>>> PO equivocates over whether he is concerned about just the
>>>>>>>>>>> one case used
>>>>>>>>>>> in the usual proof's construction or the general case, but
>>>>>>>>>>> regardless of
>>>>>>>>>>> what side of that fence he is currently sitting, you can't
>>>>>>>>>>> use his H for
>>>>>>>>>>> anything useful.
>>>>>>>>>>>
>>>>>>>>>>>> How would it know the correct answer? Will it ever return an
>>>>>>>>>>>> answer?
>>>>>>>>>>>> (Especially, _if_ there is no odd perfect number?)
>>>>>>>>>>>
>>>>>>>>>>> On some days he will claim that he has never said he has a
>>>>>>>>>>> general halt
>>>>>>>>>>> decider, just one that can't be fooled by the "usual
>>>>>>>>>>> construction".  It
>>>>>>>>>>> "can't be fooled" because he simply declares that H(H^, H^)
>>>>>>>>>>> == false is
>>>>>>>>>>> the correct answer "even though" H^(H^) halts.
>>>>>>>>>>>
>>>>>>>>>>> On other days, he throws caution to the wind and claims the
>>>>>>>>>>> general
>>>>>>>>>>> case, but again with the set of non-halting computations
>>>>>>>>>>> "augmented" by
>>>>>>>>>>> some unspecified set of halting ones.
>>>>>>>>>>>
>>>>>>>>>>> Of course, he is also not an honest disputant, because he
>>>>>>>>>>> will avoid
>>>>>>>>>>> giving a direct answer to a simple question for years
>>>>>>>>>>> (literally years),
>>>>>>>>>>> and he will even say contradictory things days apart (again,
>>>>>>>>>>> citations
>>>>>>>>>>> available on request) so it can take some time to clear all
>>>>>>>>>>> the smoke
>>>>>>>>>>> from the mirrors.  But once he has said
>>>>>>>>>>>
>>>>>>>>>>>    "Yes that is the correct answer even though P(P) halts."
>>>>>>>>>>>
>>>>>>>>>>> in reply to the question "do you still assert that H(P,P) ==
>>>>>>>>>>> false is
>>>>>>>>>>> the 'correct' answer even though P(P) halts?" I don't see any
>>>>>>>>>>> point in
>>>>>>>>>>> carrying on, or at least I see not point in saying anything
>>>>>>>>>>> else.
>>>>>>>>>>>
>>>>>>>>>>> The one weapon we have against cranks is that most can't bear
>>>>>>>>>>> to retract
>>>>>>>>>>> any substantive claim.  This is why they are usually so
>>>>>>>>>>> evasive about
>>>>>>>>>>> giving direct answers -- they know they will have to stick
>>>>>>>>>>> with them.
>>>>>>>>>>> But once they have made the mistake of being clear, we should
>>>>>>>>>>> pay them
>>>>>>>>>>> the courtesy of quoting them at every available opportunity.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Ben has already agreed that H does correctly determine that
>>>>>>>>>> halt status
>>>>>>>>>> of its input according to the Sipser approved criteria. (see
>>>>>>>>>> quote
>>>>>>>>>> below) The Sipser approved criteria is a tautology thus
>>>>>>>>>> necessarily
>>>>>>>>>> true.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Nope, you MIS-QUOTE him by removing context, which is just a
>>>>>>>>> form of LYING.
>>>>>>>>>
>>>>>>>>
>>>>>>>> The context does not change the fact that he agreed that H does
>>>>>>>> correctly determine the halt status of D according to the Sisper
>>>>>>>> approved criteria.
>>>>>>>>
>>>>>>>>>> Because all deciders only compute the mapping *from their
>>>>>>>>>> inputs* to
>>>>>>>>>> their own accept or reject state and the only objection to my
>>>>>>>>>> proof is
>>>>>>>>>> that it does not get the same result as a non-input this only
>>>>>>>>>> objection
>>>>>>>>>> is nullified. *My proof is correct by tautology*
>>>>>>>>>
>>>>>>>>> SO, what mapping is this supposed to compute, if this is what
>>>>>>>>> ALL decider do, is "Halting" the only type of decider?
>>>>>>>>>
>>>>>>>>> Remember, Halting is DEFINED as the MACHINE coming to a final
>>>>>>>>> state, and it does.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> My reviewers insist on staying one recursive invocation away from
>>>>>>>>>> reality. H does correctly determine that D correctly simulated
>>>>>>>>>> by H
>>>>>>>>>> cannot possibly terminate normally.
>>>>>>>>>
>>>>>>>>> Except YOU are one invocation from the probem. It isn't asking
>>>>>>>>> about the simulatiion done by H, but by the machine that H is
>>>>>>>>> TRYING to simulate (but can't).
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> My reviewers only focus on the behavior after H has already
>>>>>>>>>> made this
>>>>>>>>>> correct halt status decision, thus are clearly out-of-sync by one
>>>>>>>>>> recursive invocation.
>>>>>>>>>
>>>>>>>>> Because it makes the WRONG decision by the definition of the
>>>>>>>>> problem, what does the machine represented by the input do?
>>>>>>>>>
>>>>>>>>
>>>>>>>> The definition of the problem that you are referring to
>>>>>>>> contradicts the definition of a decider that must compute the
>>>>>>>> mapping from
>>>>>>>> AN INPUT
>>>>>>>> AN INPUT
>>>>>>>> AN INPUT
>>>>>>>> AN INPUT
>>>>>>>> AN INPUT
>>>>>>>> AN INPUT
>>>>>>>> AN INPUT
>>>>>>>> AN INPUT
>>>>>>>> AN INPUT
>>>>>>>> to an its own accept or reject state.
>>>>>>>>
>>>>>>>> You think that H is wrong because the outer invocation halts only
>>>>>>>> because the inner invocation was correctly aborted.
>>>>>>>>
>>>>>>>> You know that it is necessarily true that no invocation would
>>>>>>>> ever halt
>>>>>>>> unless the inner invocation was aborted, thus making the
>>>>>>>> termination of
>>>>>>>> this inner invocation necessarily correct.
>>>>>>>>
>>>>>>>
>>>>>>> I have better words. The termination of the simulation of D is
>>>>>>> mandated
>>>>>>> by the requirements that a halt decider must always halt, thus
>>>>>>> conclusively proving that this termination is necessarily correct.
>>>>>>>
>>>>>>
>>>>>> It is also mandated to give the correct answer, which since H(D,D)
>>>>>> returns 0, which causes D(D) to Halt, the only correct answer that
>>>>>> H(D,D) should give is 1, so it is necessarily incorrect.
>>>>>
>>>>> The easily verified fact that H itself would not terminate unless it
>>>>> aborted the simulation of its input conclusively proves that H is
>>>>> necessarily correct to do this and report this input as non-halting.
>>>>>
>>>>> This equally applies to the Peter Linz Turing machine based halting
>>>>> problem proof with embedded_H and ⟨Ĥ⟩.
>>>>>
>>>>
>>>> So? H not terminating is its own problem.
>>> Since it is required to terminate the choice to not abort its simulation
>>> would violate this requirement thus making this choice necessarily
>>> correct. This also conclusively proves that its input cannot possibly
>>> terminate normally thus is correctly determined to be non-halting.
>>>
>>
>> So? You still don't get it.
>>
>> yes, it is required to give an answer in finite time, so it can't just
>> be programmed to simulate forever. It also is required to return the
>> correct answer,
> Since it is true that unless H aborts its simulation of D that H itself
> never terminates normally that makes it necessarily correct to do this.

On 5/25/2023 10:47 PM, Richard Damon wrote:
> On 5/25/23 11:17 PM, olcott wrote:
>> On 5/25/2023 10:10 PM, Richard Damon wrote:
>>> On 5/25/23 10:55 PM, olcott wrote:
>>>> On 5/25/2023 9:42 PM, Richard Damon wrote:
>>>>> On 5/25/23 10:26 PM, olcott wrote:
>>>>>> On 5/25/2023 8:56 PM, Richard Damon wrote:
>>>>>>> On 5/25/23 9:43 PM, olcott wrote:
>>>>>>>> On 5/25/2023 8:29 PM, olcott wrote:
>>>>>>>>> On 5/25/2023 7:01 PM, Richard Damon wrote:
>>>>>>>>>> On 5/25/23 11:30 AM, olcott wrote:
>>>>>>>>>>> On 5/25/2023 6:16 AM, Ben Bacarisse wrote:
>>>>>>>>>>>> Fritz Feldhase <franz.fritschee.ff@gmail.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On Wednesday, May 24, 2023 at 9:14:36 PM UTC+2, Richard
>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> Following pseudocode for D:
>>>>>>>>>>>>>
>>>>>>>>>>>>> arbitrarily long int D(int start) {
>>>>>>>>>>>>>
>>>>>>>>>>>>>          arbitrarily long int n = start
>>>>>>>>>>>>>          while (n is not a perfect number) {
>>>>>>>>>>>>>          n = n + 2
>>>>>>>>>>>>>          }
>>>>>>>>>>>>>
>>>>>>>>>>>>>          return n
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> What would Olcott's "simulating halt decider" return
>>>>>>>>>>>>> (answer) if
>>>>>>>>>>>>> called with, say, H(D, 1)?
>>>>>>>>>>>>
>>>>>>>>>>>> Why would you care?  PO's H returns "does not halt" for at
>>>>>>>>>>>> least some
>>>>>>>>>>>> halting computations (citations available on request) so the
>>>>>>>>>>>> result
>>>>>>>>>>>> tells you nothing of interest.
>>>>>>>>>>>>
>>>>>>>>>>>> PO equivocates over whether he is concerned about just the
>>>>>>>>>>>> one case used
>>>>>>>>>>>> in the usual proof's construction or the general case, but
>>>>>>>>>>>> regardless of
>>>>>>>>>>>> what side of that fence he is currently sitting, you can't
>>>>>>>>>>>> use his H for
>>>>>>>>>>>> anything useful.
>>>>>>>>>>>>
>>>>>>>>>>>>> How would it know the correct answer? Will it ever return
>>>>>>>>>>>>> an answer?
>>>>>>>>>>>>> (Especially, _if_ there is no odd perfect number?)
>>>>>>>>>>>>
>>>>>>>>>>>> On some days he will claim that he has never said he has a
>>>>>>>>>>>> general halt
>>>>>>>>>>>> decider, just one that can't be fooled by the "usual
>>>>>>>>>>>> construction".  It
>>>>>>>>>>>> "can't be fooled" because he simply declares that H(H^, H^)
>>>>>>>>>>>> == false is
>>>>>>>>>>>> the correct answer "even though" H^(H^) halts.
>>>>>>>>>>>>
>>>>>>>>>>>> On other days, he throws caution to the wind and claims the
>>>>>>>>>>>> general
>>>>>>>>>>>> case, but again with the set of non-halting computations
>>>>>>>>>>>> "augmented" by
>>>>>>>>>>>> some unspecified set of halting ones.
>>>>>>>>>>>>
>>>>>>>>>>>> Of course, he is also not an honest disputant, because he
>>>>>>>>>>>> will avoid
>>>>>>>>>>>> giving a direct answer to a simple question for years
>>>>>>>>>>>> (literally years),
>>>>>>>>>>>> and he will even say contradictory things days apart (again,
>>>>>>>>>>>> citations
>>>>>>>>>>>> available on request) so it can take some time to clear all
>>>>>>>>>>>> the smoke
>>>>>>>>>>>> from the mirrors.  But once he has said
>>>>>>>>>>>>
>>>>>>>>>>>>    "Yes that is the correct answer even though P(P) halts."
>>>>>>>>>>>>
>>>>>>>>>>>> in reply to the question "do you still assert that H(P,P) ==
>>>>>>>>>>>> false is
>>>>>>>>>>>> the 'correct' answer even though P(P) halts?" I don't see
>>>>>>>>>>>> any point in
>>>>>>>>>>>> carrying on, or at least I see not point in saying anything
>>>>>>>>>>>> else.
>>>>>>>>>>>>
>>>>>>>>>>>> The one weapon we have against cranks is that most can't
>>>>>>>>>>>> bear to retract
>>>>>>>>>>>> any substantive claim.  This is why they are usually so
>>>>>>>>>>>> evasive about
>>>>>>>>>>>> giving direct answers -- they know they will have to stick
>>>>>>>>>>>> with them.
>>>>>>>>>>>> But once they have made the mistake of being clear, we
>>>>>>>>>>>> should pay them
>>>>>>>>>>>> the courtesy of quoting them at every available opportunity.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Ben has already agreed that H does correctly determine that
>>>>>>>>>>> halt status
>>>>>>>>>>> of its input according to the Sipser approved criteria. (see
>>>>>>>>>>> quote
>>>>>>>>>>> below) The Sipser approved criteria is a tautology thus
>>>>>>>>>>> necessarily
>>>>>>>>>>> true.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Nope, you MIS-QUOTE him by removing context, which is just a
>>>>>>>>>> form of LYING.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The context does not change the fact that he agreed that H does
>>>>>>>>> correctly determine the halt status of D according to the
>>>>>>>>> Sisper approved criteria.
>>>>>>>>>
>>>>>>>>>>> Because all deciders only compute the mapping *from their
>>>>>>>>>>> inputs* to
>>>>>>>>>>> their own accept or reject state and the only objection to my
>>>>>>>>>>> proof is
>>>>>>>>>>> that it does not get the same result as a non-input this only
>>>>>>>>>>> objection
>>>>>>>>>>> is nullified. *My proof is correct by tautology*
>>>>>>>>>>
>>>>>>>>>> SO, what mapping is this supposed to compute, if this is what
>>>>>>>>>> ALL decider do, is "Halting" the only type of decider?
>>>>>>>>>>
>>>>>>>>>> Remember, Halting is DEFINED as the MACHINE coming to a final
>>>>>>>>>> state, and it does.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> My reviewers insist on staying one recursive invocation away
>>>>>>>>>>> from
>>>>>>>>>>> reality. H does correctly determine that D correctly
>>>>>>>>>>> simulated by H
>>>>>>>>>>> cannot possibly terminate normally.
>>>>>>>>>>
>>>>>>>>>> Except YOU are one invocation from the probem. It isn't asking
>>>>>>>>>> about the simulatiion done by H, but by the machine that H is
>>>>>>>>>> TRYING to simulate (but can't).
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> My reviewers only focus on the behavior after H has already
>>>>>>>>>>> made this
>>>>>>>>>>> correct halt status decision, thus are clearly out-of-sync by
>>>>>>>>>>> one
>>>>>>>>>>> recursive invocation.
>>>>>>>>>>
>>>>>>>>>> Because it makes the WRONG decision by the definition of the
>>>>>>>>>> problem, what does the machine represented by the input do?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The definition of the problem that you are referring to
>>>>>>>>> contradicts the definition of a decider that must compute the
>>>>>>>>> mapping from
>>>>>>>>> AN INPUT
>>>>>>>>> AN INPUT
>>>>>>>>> AN INPUT
>>>>>>>>> AN INPUT
>>>>>>>>> AN INPUT
>>>>>>>>> AN INPUT
>>>>>>>>> AN INPUT
>>>>>>>>> AN INPUT
>>>>>>>>> AN INPUT
>>>>>>>>> to an its own accept or reject state.
>>>>>>>>>
>>>>>>>>> You think that H is wrong because the outer invocation halts only
>>>>>>>>> because the inner invocation was correctly aborted.
>>>>>>>>>
>>>>>>>>> You know that it is necessarily true that no invocation would
>>>>>>>>> ever halt
>>>>>>>>> unless the inner invocation was aborted, thus making the
>>>>>>>>> termination of
>>>>>>>>> this inner invocation necessarily correct.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I have better words. The termination of the simulation of D is
>>>>>>>> mandated
>>>>>>>> by the requirements that a halt decider must always halt, thus
>>>>>>>> conclusively proving that this termination is necessarily correct.
>>>>>>>>
>>>>>>>
>>>>>>> It is also mandated to give the correct answer, which since
>>>>>>> H(D,D) returns 0, which causes D(D) to Halt, the only correct
>>>>>>> answer that H(D,D) should give is 1, so it is necessarily incorrect.
>>>>>>
>>>>>> The easily verified fact that H itself would not terminate unless it
>>>>>> aborted the simulation of its input conclusively proves that H is
>>>>>> necessarily correct to do this and report this input as non-halting.
>>>>>>
>>>>>> This equally applies to the Peter Linz Turing machine based halting
>>>>>> problem proof with embedded_H and ⟨Ĥ⟩.
>>>>>>
>>>>>
>>>>> So? H not terminating is its own problem.
>>>> Since it is required to terminate the choice to not abort its
>>>> simulation
>>>> would violate this requirement thus making this choice necessarily
>>>> correct. This also conclusively proves that its input cannot possibly
>>>> terminate normally thus is correctly determined to be non-halting.
>>>>
>>>
>>> So? You still don't get it.
>>>
>>> yes, it is required to give an answer in finite time, so it can't
>>> just be programmed to simulate forever. It also is required to return
>>> the correct answer,
>> Since it is true that unless H aborts its simulation of D that H itself
>> never terminates normally that makes it necessarily correct to do this.
>
> So, you are admitting that H doesn't actually "terminate normally" and
> thus fails to be a decider?
>

On 5/25/23 11:59 PM, olcott wrote:
> On 5/25/2023 10:47 PM, Richard Damon wrote:
>> On 5/25/23 11:17 PM, olcott wrote:
>>> On 5/25/2023 10:10 PM, Richard Damon wrote:
>>>> On 5/25/23 10:55 PM, olcott wrote:
>>>>> On 5/25/2023 9:42 PM, Richard Damon wrote:
>>>>>> On 5/25/23 10:26 PM, olcott wrote:
>>>>>>> On 5/25/2023 8:56 PM, Richard Damon wrote:
>>>>>>>> On 5/25/23 9:43 PM, olcott wrote:
>>>>>>>>> On 5/25/2023 8:29 PM, olcott wrote:
>>>>>>>>>> On 5/25/2023 7:01 PM, Richard Damon wrote:
>>>>>>>>>>> On 5/25/23 11:30 AM, olcott wrote:
>>>>>>>>>>>> On 5/25/2023 6:16 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>> Fritz Feldhase <franz.fritschee.ff@gmail.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On Wednesday, May 24, 2023 at 9:14:36 PM UTC+2, Richard
>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Following pseudocode for D:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> arbitrarily long int D(int start) {
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>          arbitrarily long int n = start
>>>>>>>>>>>>>>          while (n is not a perfect number) {
>>>>>>>>>>>>>>          n = n + 2
>>>>>>>>>>>>>>          }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>          return n
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> What would Olcott's "simulating halt decider" return
>>>>>>>>>>>>>> (answer) if
>>>>>>>>>>>>>> called with, say, H(D, 1)?
>>>>>>>>>>>>>
>>>>>>>>>>>>> Why would you care?  PO's H returns "does not halt" for at
>>>>>>>>>>>>> least some
>>>>>>>>>>>>> halting computations (citations available on request) so
>>>>>>>>>>>>> the result
>>>>>>>>>>>>> tells you nothing of interest.
>>>>>>>>>>>>>
>>>>>>>>>>>>> PO equivocates over whether he is concerned about just the
>>>>>>>>>>>>> one case used
>>>>>>>>>>>>> in the usual proof's construction or the general case, but
>>>>>>>>>>>>> regardless of
>>>>>>>>>>>>> what side of that fence he is currently sitting, you can't
>>>>>>>>>>>>> use his H for
>>>>>>>>>>>>> anything useful.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> How would it know the correct answer? Will it ever return
>>>>>>>>>>>>>> an answer?
>>>>>>>>>>>>>> (Especially, _if_ there is no odd perfect number?)
>>>>>>>>>>>>>
>>>>>>>>>>>>> On some days he will claim that he has never said he has a
>>>>>>>>>>>>> general halt
>>>>>>>>>>>>> decider, just one that can't be fooled by the "usual
>>>>>>>>>>>>> construction".  It
>>>>>>>>>>>>> "can't be fooled" because he simply declares that H(H^, H^)
>>>>>>>>>>>>> == false is
>>>>>>>>>>>>> the correct answer "even though" H^(H^) halts.
>>>>>>>>>>>>>
>>>>>>>>>>>>> On other days, he throws caution to the wind and claims the
>>>>>>>>>>>>> general
>>>>>>>>>>>>> case, but again with the set of non-halting computations
>>>>>>>>>>>>> "augmented" by
>>>>>>>>>>>>> some unspecified set of halting ones.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Of course, he is also not an honest disputant, because he
>>>>>>>>>>>>> will avoid
>>>>>>>>>>>>> giving a direct answer to a simple question for years
>>>>>>>>>>>>> (literally years),
>>>>>>>>>>>>> and he will even say contradictory things days apart
>>>>>>>>>>>>> (again, citations
>>>>>>>>>>>>> available on request) so it can take some time to clear all
>>>>>>>>>>>>> the smoke
>>>>>>>>>>>>> from the mirrors.  But once he has said
>>>>>>>>>>>>>
>>>>>>>>>>>>>    "Yes that is the correct answer even though P(P) halts."
>>>>>>>>>>>>>
>>>>>>>>>>>>> in reply to the question "do you still assert that H(P,P)
>>>>>>>>>>>>> == false is
>>>>>>>>>>>>> the 'correct' answer even though P(P) halts?" I don't see
>>>>>>>>>>>>> any point in
>>>>>>>>>>>>> carrying on, or at least I see not point in saying anything
>>>>>>>>>>>>> else.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The one weapon we have against cranks is that most can't
>>>>>>>>>>>>> bear to retract
>>>>>>>>>>>>> any substantive claim.  This is why they are usually so
>>>>>>>>>>>>> evasive about
>>>>>>>>>>>>> giving direct answers -- they know they will have to stick
>>>>>>>>>>>>> with them.
>>>>>>>>>>>>> But once they have made the mistake of being clear, we
>>>>>>>>>>>>> should pay them
>>>>>>>>>>>>> the courtesy of quoting them at every available opportunity.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Ben has already agreed that H does correctly determine that
>>>>>>>>>>>> halt status
>>>>>>>>>>>> of its input according to the Sipser approved criteria. (see
>>>>>>>>>>>> quote
>>>>>>>>>>>> below) The Sipser approved criteria is a tautology thus
>>>>>>>>>>>> necessarily
>>>>>>>>>>>> true.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Nope, you MIS-QUOTE him by removing context, which is just a
>>>>>>>>>>> form of LYING.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The context does not change the fact that he agreed that H does
>>>>>>>>>> correctly determine the halt status of D according to the
>>>>>>>>>> Sisper approved criteria.
>>>>>>>>>>
>>>>>>>>>>>> Because all deciders only compute the mapping *from their
>>>>>>>>>>>> inputs* to
>>>>>>>>>>>> their own accept or reject state and the only objection to
>>>>>>>>>>>> my proof is
>>>>>>>>>>>> that it does not get the same result as a non-input this
>>>>>>>>>>>> only objection
>>>>>>>>>>>> is nullified. *My proof is correct by tautology*
>>>>>>>>>>>
>>>>>>>>>>> SO, what mapping is this supposed to compute, if this is what
>>>>>>>>>>> ALL decider do, is "Halting" the only type of decider?
>>>>>>>>>>>
>>>>>>>>>>> Remember, Halting is DEFINED as the MACHINE coming to a final
>>>>>>>>>>> state, and it does.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> My reviewers insist on staying one recursive invocation away
>>>>>>>>>>>> from
>>>>>>>>>>>> reality. H does correctly determine that D correctly
>>>>>>>>>>>> simulated by H
>>>>>>>>>>>> cannot possibly terminate normally.
>>>>>>>>>>>
>>>>>>>>>>> Except YOU are one invocation from the probem. It isn't
>>>>>>>>>>> asking about the simulatiion done by H, but by the machine
>>>>>>>>>>> that H is TRYING to simulate (but can't).
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> My reviewers only focus on the behavior after H has already
>>>>>>>>>>>> made this
>>>>>>>>>>>> correct halt status decision, thus are clearly out-of-sync
>>>>>>>>>>>> by one
>>>>>>>>>>>> recursive invocation.
>>>>>>>>>>>
>>>>>>>>>>> Because it makes the WRONG decision by the definition of the
>>>>>>>>>>> problem, what does the machine represented by the input do?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The definition of the problem that you are referring to
>>>>>>>>>> contradicts the definition of a decider that must compute the
>>>>>>>>>> mapping from
>>>>>>>>>> AN INPUT
>>>>>>>>>> AN INPUT
>>>>>>>>>> AN INPUT
>>>>>>>>>> AN INPUT
>>>>>>>>>> AN INPUT
>>>>>>>>>> AN INPUT
>>>>>>>>>> AN INPUT
>>>>>>>>>> AN INPUT
>>>>>>>>>> AN INPUT
>>>>>>>>>> to an its own accept or reject state.
>>>>>>>>>>
>>>>>>>>>> You think that H is wrong because the outer invocation halts only
>>>>>>>>>> because the inner invocation was correctly aborted.
>>>>>>>>>>
>>>>>>>>>> You know that it is necessarily true that no invocation would
>>>>>>>>>> ever halt
>>>>>>>>>> unless the inner invocation was aborted, thus making the
>>>>>>>>>> termination of
>>>>>>>>>> this inner invocation necessarily correct.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I have better words. The termination of the simulation of D is
>>>>>>>>> mandated
>>>>>>>>> by the requirements that a halt decider must always halt, thus
>>>>>>>>> conclusively proving that this termination is necessarily correct.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It is also mandated to give the correct answer, which since
>>>>>>>> H(D,D) returns 0, which causes D(D) to Halt, the only correct
>>>>>>>> answer that H(D,D) should give is 1, so it is necessarily
>>>>>>>> incorrect.
>>>>>>>
>>>>>>> The easily verified fact that H itself would not terminate unless it
>>>>>>> aborted the simulation of its input conclusively proves that H is
>>>>>>> necessarily correct to do this and report this input as non-halting.
>>>>>>>
>>>>>>> This equally applies to the Peter Linz Turing machine based halting
>>>>>>> problem proof with embedded_H and ⟨Ĥ⟩.
>>>>>>>
>>>>>>
>>>>>> So? H not terminating is its own problem.
>>>>> Since it is required to terminate the choice to not abort its
>>>>> simulation
>>>>> would violate this requirement thus making this choice necessarily
>>>>> correct. This also conclusively proves that its input cannot possibly
>>>>> terminate normally thus is correctly determined to be non-halting.
>>>>>
>>>>
>>>> So? You still don't get it.
>>>>
>>>> yes, it is required to give an answer in finite time, so it can't
>>>> just be programmed to simulate forever. It also is required to
>>>> return the correct answer,
>>> Since it is true that unless H aborts its simulation of D that H itself
>>> never terminates normally that makes it necessarily correct to do this.
>>
>> So, you are admitting that H doesn't actually "terminate normally" and
>> thus fails to be a decider?
>>
>
> Your software engineering skill must be quite awfully terrible to make a
> mistake like that.

On 5/25/2023 11:10 PM, Richard Damon wrote:
> On 5/25/23 11:59 PM, olcott wrote:
>> On 5/25/2023 10:47 PM, Richard Damon wrote:
>>> On 5/25/23 11:17 PM, olcott wrote:
>>>> On 5/25/2023 10:10 PM, Richard Damon wrote:
>>>>> On 5/25/23 10:55 PM, olcott wrote:
>>>>>> On 5/25/2023 9:42 PM, Richard Damon wrote:
>>>>>>> On 5/25/23 10:26 PM, olcott wrote:
>>>>>>>> On 5/25/2023 8:56 PM, Richard Damon wrote:
>>>>>>>>> On 5/25/23 9:43 PM, olcott wrote:
>>>>>>>>>> On 5/25/2023 8:29 PM, olcott wrote:
>>>>>>>>>>> On 5/25/2023 7:01 PM, Richard Damon wrote:
>>>>>>>>>>>> On 5/25/23 11:30 AM, olcott wrote:
>>>>>>>>>>>>> On 5/25/2023 6:16 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> Fritz Feldhase <franz.fritschee.ff@gmail.com> writes:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On Wednesday, May 24, 2023 at 9:14:36 PM UTC+2, Richard
>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Following pseudocode for D:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> arbitrarily long int D(int start) {
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>          arbitrarily long int n = start
>>>>>>>>>>>>>>>          while (n is not a perfect number) {
>>>>>>>>>>>>>>>          n = n + 2
>>>>>>>>>>>>>>>          }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>          return n
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> What would Olcott's "simulating halt decider" return
>>>>>>>>>>>>>>> (answer) if
>>>>>>>>>>>>>>> called with, say, H(D, 1)?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Why would you care?  PO's H returns "does not halt" for at
>>>>>>>>>>>>>> least some
>>>>>>>>>>>>>> halting computations (citations available on request) so
>>>>>>>>>>>>>> the result
>>>>>>>>>>>>>> tells you nothing of interest.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> PO equivocates over whether he is concerned about just the
>>>>>>>>>>>>>> one case used
>>>>>>>>>>>>>> in the usual proof's construction or the general case, but
>>>>>>>>>>>>>> regardless of
>>>>>>>>>>>>>> what side of that fence he is currently sitting, you can't
>>>>>>>>>>>>>> use his H for
>>>>>>>>>>>>>> anything useful.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> How would it know the correct answer? Will it ever return
>>>>>>>>>>>>>>> an answer?
>>>>>>>>>>>>>>> (Especially, _if_ there is no odd perfect number?)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On some days he will claim that he has never said he has a
>>>>>>>>>>>>>> general halt
>>>>>>>>>>>>>> decider, just one that can't be fooled by the "usual
>>>>>>>>>>>>>> construction".  It
>>>>>>>>>>>>>> "can't be fooled" because he simply declares that H(H^,
>>>>>>>>>>>>>> H^) == false is
>>>>>>>>>>>>>> the correct answer "even though" H^(H^) halts.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On other days, he throws caution to the wind and claims
>>>>>>>>>>>>>> the general
>>>>>>>>>>>>>> case, but again with the set of non-halting computations
>>>>>>>>>>>>>> "augmented" by
>>>>>>>>>>>>>> some unspecified set of halting ones.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Of course, he is also not an honest disputant, because he
>>>>>>>>>>>>>> will avoid
>>>>>>>>>>>>>> giving a direct answer to a simple question for years
>>>>>>>>>>>>>> (literally years),
>>>>>>>>>>>>>> and he will even say contradictory things days apart
>>>>>>>>>>>>>> (again, citations
>>>>>>>>>>>>>> available on request) so it can take some time to clear
>>>>>>>>>>>>>> all the smoke
>>>>>>>>>>>>>> from the mirrors.  But once he has said
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>    "Yes that is the correct answer even though P(P) halts."
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> in reply to the question "do you still assert that H(P,P)
>>>>>>>>>>>>>> == false is
>>>>>>>>>>>>>> the 'correct' answer even though P(P) halts?" I don't see
>>>>>>>>>>>>>> any point in
>>>>>>>>>>>>>> carrying on, or at least I see not point in saying
>>>>>>>>>>>>>> anything else.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The one weapon we have against cranks is that most can't
>>>>>>>>>>>>>> bear to retract
>>>>>>>>>>>>>> any substantive claim.  This is why they are usually so
>>>>>>>>>>>>>> evasive about
>>>>>>>>>>>>>> giving direct answers -- they know they will have to stick
>>>>>>>>>>>>>> with them.
>>>>>>>>>>>>>> But once they have made the mistake of being clear, we
>>>>>>>>>>>>>> should pay them
>>>>>>>>>>>>>> the courtesy of quoting them at every available opportunity.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ben has already agreed that H does correctly determine that
>>>>>>>>>>>>> halt status
>>>>>>>>>>>>> of its input according to the Sipser approved criteria.
>>>>>>>>>>>>> (see quote
>>>>>>>>>>>>> below) The Sipser approved criteria is a tautology thus
>>>>>>>>>>>>> necessarily
>>>>>>>>>>>>> true.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, you MIS-QUOTE him by removing context, which is just a
>>>>>>>>>>>> form of LYING.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The context does not change the fact that he agreed that H does
>>>>>>>>>>> correctly determine the halt status of D according to the
>>>>>>>>>>> Sisper approved criteria.
>>>>>>>>>>>
>>>>>>>>>>>>> Because all deciders only compute the mapping *from their
>>>>>>>>>>>>> inputs* to
>>>>>>>>>>>>> their own accept or reject state and the only objection to
>>>>>>>>>>>>> my proof is
>>>>>>>>>>>>> that it does not get the same result as a non-input this
>>>>>>>>>>>>> only objection
>>>>>>>>>>>>> is nullified. *My proof is correct by tautology*
>>>>>>>>>>>>
>>>>>>>>>>>> SO, what mapping is this supposed to compute, if this is
>>>>>>>>>>>> what ALL decider do, is "Halting" the only type of decider?
>>>>>>>>>>>>
>>>>>>>>>>>> Remember, Halting is DEFINED as the MACHINE coming to a
>>>>>>>>>>>> final state, and it does.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> My reviewers insist on staying one recursive invocation
>>>>>>>>>>>>> away from
>>>>>>>>>>>>> reality. H does correctly determine that D correctly
>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>> cannot possibly terminate normally.
>>>>>>>>>>>>
>>>>>>>>>>>> Except YOU are one invocation from the probem. It isn't
>>>>>>>>>>>> asking about the simulatiion done by H, but by the machine
>>>>>>>>>>>> that H is TRYING to simulate (but can't).
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> My reviewers only focus on the behavior after H has already
>>>>>>>>>>>>> made this
>>>>>>>>>>>>> correct halt status decision, thus are clearly out-of-sync
>>>>>>>>>>>>> by one
>>>>>>>>>>>>> recursive invocation.
>>>>>>>>>>>>
>>>>>>>>>>>> Because it makes the WRONG decision by the definition of the
>>>>>>>>>>>> problem, what does the machine represented by the input do?
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The definition of the problem that you are referring to
>>>>>>>>>>> contradicts the definition of a decider that must compute the
>>>>>>>>>>> mapping from
>>>>>>>>>>> AN INPUT
>>>>>>>>>>> AN INPUT
>>>>>>>>>>> AN INPUT
>>>>>>>>>>> AN INPUT
>>>>>>>>>>> AN INPUT
>>>>>>>>>>> AN INPUT
>>>>>>>>>>> AN INPUT
>>>>>>>>>>> AN INPUT
>>>>>>>>>>> AN INPUT
>>>>>>>>>>> to an its own accept or reject state.
>>>>>>>>>>>
>>>>>>>>>>> You think that H is wrong because the outer invocation halts
>>>>>>>>>>> only
>>>>>>>>>>> because the inner invocation was correctly aborted.
>>>>>>>>>>>
>>>>>>>>>>> You know that it is necessarily true that no invocation would
>>>>>>>>>>> ever halt
>>>>>>>>>>> unless the inner invocation was aborted, thus making the
>>>>>>>>>>> termination of
>>>>>>>>>>> this inner invocation necessarily correct.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I have better words. The termination of the simulation of D is
>>>>>>>>>> mandated
>>>>>>>>>> by the requirements that a halt decider must always halt, thus
>>>>>>>>>> conclusively proving that this termination is necessarily
>>>>>>>>>> correct.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is also mandated to give the correct answer, which since
>>>>>>>>> H(D,D) returns 0, which causes D(D) to Halt, the only correct
>>>>>>>>> answer that H(D,D) should give is 1, so it is necessarily
>>>>>>>>> incorrect.
>>>>>>>>
>>>>>>>> The easily verified fact that H itself would not terminate
>>>>>>>> unless it
>>>>>>>> aborted the simulation of its input conclusively proves that H is
>>>>>>>> necessarily correct to do this and report this input as
>>>>>>>> non-halting.
>>>>>>>>
>>>>>>>> This equally applies to the Peter Linz Turing machine based halting
>>>>>>>> problem proof with embedded_H and ⟨Ĥ⟩.
>>>>>>>>
>>>>>>>
>>>>>>> So? H not terminating is its own problem.
>>>>>> Since it is required to terminate the choice to not abort its
>>>>>> simulation
>>>>>> would violate this requirement thus making this choice necessarily
>>>>>> correct. This also conclusively proves that its input cannot possibly
>>>>>> terminate normally thus is correctly determined to be non-halting.
>>>>>>
>>>>>
>>>>> So? You still don't get it.
>>>>>
>>>>> yes, it is required to give an answer in finite time, so it can't
>>>>> just be programmed to simulate forever. It also is required to
>>>>> return the correct answer,
>>>> Since it is true that unless H aborts its simulation of D that H itself
>>>> never terminates normally that makes it necessarily correct to do this.
>>>
>>> So, you are admitting that H doesn't actually "terminate normally"
>>> and thus fails to be a decider?
>>>
>>
>> Your software engineering skill must be quite awfully terrible to make
>> a mistake like that.
>
>
> So, does H "Terminate Normally", at which point, so does the D, or does
> H not "Terminate Normally" and thus isn't a decider?
>

On 5/26/23 1:06 AM, olcott wrote:
> On 5/25/2023 11:10 PM, Richard Damon wrote:
>> On 5/25/23 11:59 PM, olcott wrote:
>>> On 5/25/2023 10:47 PM, Richard Damon wrote:
>>>> On 5/25/23 11:17 PM, olcott wrote:
>>>>> On 5/25/2023 10:10 PM, Richard Damon wrote:
>>>>>> On 5/25/23 10:55 PM, olcott wrote:
>>>>>>> On 5/25/2023 9:42 PM, Richard Damon wrote:
>>>>>>>> On 5/25/23 10:26 PM, olcott wrote:
>>>>>>>>> On 5/25/2023 8:56 PM, Richard Damon wrote:
>>>>>>>>>> On 5/25/23 9:43 PM, olcott wrote:
>>>>>>>>>>> On 5/25/2023 8:29 PM, olcott wrote:
>>>>>>>>>>>> On 5/25/2023 7:01 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 5/25/23 11:30 AM, olcott wrote:
>>>>>>>>>>>>>> On 5/25/2023 6:16 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>>>> Fritz Feldhase <franz.fritschee.ff@gmail.com> writes:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On Wednesday, May 24, 2023 at 9:14:36 PM UTC+2, Richard
>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Following pseudocode for D:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> arbitrarily long int D(int start) {
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>          arbitrarily long int n = start
>>>>>>>>>>>>>>>>          while (n is not a perfect number) {
>>>>>>>>>>>>>>>>          n = n + 2
>>>>>>>>>>>>>>>>          }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>          return n
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> What would Olcott's "simulating halt decider" return
>>>>>>>>>>>>>>>> (answer) if
>>>>>>>>>>>>>>>> called with, say, H(D, 1)?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Why would you care?  PO's H returns "does not halt" for
>>>>>>>>>>>>>>> at least some
>>>>>>>>>>>>>>> halting computations (citations available on request) so
>>>>>>>>>>>>>>> the result
>>>>>>>>>>>>>>> tells you nothing of interest.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> PO equivocates over whether he is concerned about just
>>>>>>>>>>>>>>> the one case used
>>>>>>>>>>>>>>> in the usual proof's construction or the general case,
>>>>>>>>>>>>>>> but regardless of
>>>>>>>>>>>>>>> what side of that fence he is currently sitting, you
>>>>>>>>>>>>>>> can't use his H for
>>>>>>>>>>>>>>> anything useful.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> How would it know the correct answer? Will it ever
>>>>>>>>>>>>>>>> return an answer?
>>>>>>>>>>>>>>>> (Especially, _if_ there is no odd perfect number?)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On some days he will claim that he has never said he has
>>>>>>>>>>>>>>> a general halt
>>>>>>>>>>>>>>> decider, just one that can't be fooled by the "usual
>>>>>>>>>>>>>>> construction".  It
>>>>>>>>>>>>>>> "can't be fooled" because he simply declares that H(H^,
>>>>>>>>>>>>>>> H^) == false is
>>>>>>>>>>>>>>> the correct answer "even though" H^(H^) halts.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On other days, he throws caution to the wind and claims
>>>>>>>>>>>>>>> the general
>>>>>>>>>>>>>>> case, but again with the set of non-halting computations
>>>>>>>>>>>>>>> "augmented" by
>>>>>>>>>>>>>>> some unspecified set of halting ones.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Of course, he is also not an honest disputant, because he
>>>>>>>>>>>>>>> will avoid
>>>>>>>>>>>>>>> giving a direct answer to a simple question for years
>>>>>>>>>>>>>>> (literally years),
>>>>>>>>>>>>>>> and he will even say contradictory things days apart
>>>>>>>>>>>>>>> (again, citations
>>>>>>>>>>>>>>> available on request) so it can take some time to clear
>>>>>>>>>>>>>>> all the smoke
>>>>>>>>>>>>>>> from the mirrors.  But once he has said
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>    "Yes that is the correct answer even though P(P) halts."
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> in reply to the question "do you still assert that H(P,P)
>>>>>>>>>>>>>>> == false is
>>>>>>>>>>>>>>> the 'correct' answer even though P(P) halts?" I don't see
>>>>>>>>>>>>>>> any point in
>>>>>>>>>>>>>>> carrying on, or at least I see not point in saying
>>>>>>>>>>>>>>> anything else.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The one weapon we have against cranks is that most can't
>>>>>>>>>>>>>>> bear to retract
>>>>>>>>>>>>>>> any substantive claim.  This is why they are usually so
>>>>>>>>>>>>>>> evasive about
>>>>>>>>>>>>>>> giving direct answers -- they know they will have to
>>>>>>>>>>>>>>> stick with them.
>>>>>>>>>>>>>>> But once they have made the mistake of being clear, we
>>>>>>>>>>>>>>> should pay them
>>>>>>>>>>>>>>> the courtesy of quoting them at every available opportunity.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ben has already agreed that H does correctly determine
>>>>>>>>>>>>>> that halt status
>>>>>>>>>>>>>> of its input according to the Sipser approved criteria.
>>>>>>>>>>>>>> (see quote
>>>>>>>>>>>>>> below) The Sipser approved criteria is a tautology thus
>>>>>>>>>>>>>> necessarily
>>>>>>>>>>>>>> true.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope, you MIS-QUOTE him by removing context, which is just
>>>>>>>>>>>>> a form of LYING.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The context does not change the fact that he agreed that H does
>>>>>>>>>>>> correctly determine the halt status of D according to the
>>>>>>>>>>>> Sisper approved criteria.
>>>>>>>>>>>>
>>>>>>>>>>>>>> Because all deciders only compute the mapping *from their
>>>>>>>>>>>>>> inputs* to
>>>>>>>>>>>>>> their own accept or reject state and the only objection to
>>>>>>>>>>>>>> my proof is
>>>>>>>>>>>>>> that it does not get the same result as a non-input this
>>>>>>>>>>>>>> only objection
>>>>>>>>>>>>>> is nullified. *My proof is correct by tautology*
>>>>>>>>>>>>>
>>>>>>>>>>>>> SO, what mapping is this supposed to compute, if this is
>>>>>>>>>>>>> what ALL decider do, is "Halting" the only type of decider?
>>>>>>>>>>>>>
>>>>>>>>>>>>> Remember, Halting is DEFINED as the MACHINE coming to a
>>>>>>>>>>>>> final state, and it does.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> My reviewers insist on staying one recursive invocation
>>>>>>>>>>>>>> away from
>>>>>>>>>>>>>> reality. H does correctly determine that D correctly
>>>>>>>>>>>>>> simulated by H
>>>>>>>>>>>>>> cannot possibly terminate normally.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Except YOU are one invocation from the probem. It isn't
>>>>>>>>>>>>> asking about the simulatiion done by H, but by the machine
>>>>>>>>>>>>> that H is TRYING to simulate (but can't).
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> My reviewers only focus on the behavior after H has
>>>>>>>>>>>>>> already made this
>>>>>>>>>>>>>> correct halt status decision, thus are clearly out-of-sync
>>>>>>>>>>>>>> by one
>>>>>>>>>>>>>> recursive invocation.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Because it makes the WRONG decision by the definition of
>>>>>>>>>>>>> the problem, what does the machine represented by the input
>>>>>>>>>>>>> do?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The definition of the problem that you are referring to
>>>>>>>>>>>> contradicts the definition of a decider that must compute
>>>>>>>>>>>> the mapping from
>>>>>>>>>>>> AN INPUT
>>>>>>>>>>>> AN INPUT
>>>>>>>>>>>> AN INPUT
>>>>>>>>>>>> AN INPUT
>>>>>>>>>>>> AN INPUT
>>>>>>>>>>>> AN INPUT
>>>>>>>>>>>> AN INPUT
>>>>>>>>>>>> AN INPUT
>>>>>>>>>>>> AN INPUT
>>>>>>>>>>>> to an its own accept or reject state.
>>>>>>>>>>>>
>>>>>>>>>>>> You think that H is wrong because the outer invocation halts
>>>>>>>>>>>> only
>>>>>>>>>>>> because the inner invocation was correctly aborted.
>>>>>>>>>>>>
>>>>>>>>>>>> You know that it is necessarily true that no invocation
>>>>>>>>>>>> would ever halt
>>>>>>>>>>>> unless the inner invocation was aborted, thus making the
>>>>>>>>>>>> termination of
>>>>>>>>>>>> this inner invocation necessarily correct.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I have better words. The termination of the simulation of D
>>>>>>>>>>> is mandated
>>>>>>>>>>> by the requirements that a halt decider must always halt, thus
>>>>>>>>>>> conclusively proving that this termination is necessarily
>>>>>>>>>>> correct.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is also mandated to give the correct answer, which since
>>>>>>>>>> H(D,D) returns 0, which causes D(D) to Halt, the only correct
>>>>>>>>>> answer that H(D,D) should give is 1, so it is necessarily
>>>>>>>>>> incorrect.
>>>>>>>>>
>>>>>>>>> The easily verified fact that H itself would not terminate
>>>>>>>>> unless it
>>>>>>>>> aborted the simulation of its input conclusively proves that H is
>>>>>>>>> necessarily correct to do this and report this input as
>>>>>>>>> non-halting.
>>>>>>>>>
>>>>>>>>> This equally applies to the Peter Linz Turing machine based
>>>>>>>>> halting
>>>>>>>>> problem proof with embedded_H and ⟨Ĥ⟩.
>>>>>>>>>
>>>>>>>>
>>>>>>>> So? H not terminating is its own problem.
>>>>>>> Since it is required to terminate the choice to not abort its
>>>>>>> simulation
>>>>>>> would violate this requirement thus making this choice necessarily
>>>>>>> correct. This also conclusively proves that its input cannot
>>>>>>> possibly
>>>>>>> terminate normally thus is correctly determined to be non-halting.
>>>>>>>
>>>>>>
>>>>>> So? You still don't get it.
>>>>>>
>>>>>> yes, it is required to give an answer in finite time, so it can't
>>>>>> just be programmed to simulate forever. It also is required to
>>>>>> return the correct answer,
>>>>> Since it is true that unless H aborts its simulation of D that H
>>>>> itself
>>>>> never terminates normally that makes it necessarily correct to do
>>>>> this.
>>>>
>>>> So, you are admitting that H doesn't actually "terminate normally"
>>>> and thus fails to be a decider?
>>>>
>>>
>>> Your software engineering skill must be quite awfully terrible to
>>> make a mistake like that.
>>
>>
>> So, does H "Terminate Normally", at which point, so does the D, or
>> does H not "Terminate Normally" and thus isn't a decider?
>>
>
> // The following is written in C
> 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 }
> 08
> 09 void main()
> 10 {
> 11    D(D);
> 12 }
>
> *Execution Trace*
> main() invokes D(D) at line 11
> executed D(D) invokes H(D,D) that simulates D(D) at line 03 ...
>
> *keeps repeating*
> simulated D(D) invokes simulated H(D,D) that simulates D(D) at line 03 ...
>
> The simulated D cannot possibly terminate normally and H will
> never return to its caller unless and until H aborts its simulation.