• Re: Can D simulated by H terminate normally? [correct answer]

    From Richard Damon@21:1/5 to olcott on Thu May 25 22:42:56 2023
    XPost: sci.logic, comp.theory

    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. It still needs to give the
    right answer. You can't just assume an answer is right because you can't
    prove the other answer is right.

    All you have done is proved that H can't prove the correct answer, not
    that the answer it gives is correct.

    You are just showing that your "Correct Reasoning" is anything like
    actually correct reasoning, because it claims wrong answers must be correct.

    You are just proving that you are a ignorant pathological lying idiot
    because you can't see that H saying a progrma that halts is non-halting
    because it can't prove to itself that it is halting.

    You are just showing how STUPID You are.

    It seems you just can't even understand basic English.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Thu May 25 21:26:47 2023
    XPost: sci.logic, comp.theory

    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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Thu May 25 21:55:21 2023
    XPost: sci.logic, comp.theory

    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.



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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Thu May 25 23:10:42 2023
    XPost: sci.logic, comp.theory

    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, and can't use needing to give an answer as a reason for
    giving the wrong answer.

    But, since it DOES abort its simulation, and return 0 when it does, that
    makes the machine it is simulating, which is what the question is about, actually halt, and a correct simulation of this exact same input shows
    that behavior, so the non-halting answer is necessarily incorrect.

    Your logic assumes that the H that D calls doesn't do the same thing as
    the H that is answering, which means your whole arguement is based on a
    LIE, as, if H is an equiivalent to a Turing Machine, as clainmed, then
    all copies of it will behave exactly the same when given the same input,
    and D must be built with a copy of the H that is claimed to be giving
    the correct answer.

    Thus, you are just proving yourself to be a LIAR, or a total idiot that
    doesn't understand ANYTHING about what he is talking about, and since
    you are claiming to be an EXPERT, you are lying about something.

    Remember, the ACTUAL PROBLEM is about the machine descxribed by its input.

    Switching to looking at a simulation involves accepting requirements on
    that simulation, which H doesn't meet, so you are just showing you are
    an ignorant pathological lying idiot.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Thu May 25 22:17:59 2023
    XPost: sci.logic, comp.theory

    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.

    That you refer to the behavior of executed D after H has already
    aborted its simulated of D is one recursive invocation away from
    reality.

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Thu May 25 22:59:36 2023
    XPost: sci.logic, comp.theory

    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.

    Or is H actually two different programs that you claim to be just one?


    The outer D behaves differently after its own inner D has been aborted
    than the inner D that must be aborted behaves.


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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Thu May 25 23:47:51 2023
    XPost: sci.logic, comp.theory

    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?

    Or is H actually two different programs that you claim to be just one?

    You have at times claimed that H behaves differently under different
    conditions but have also demonstarted that this statement is incorrect
    by failing to provide the simple evidence to demonstart how that could
    happen.

    In other words, you LIE.


    That you refer to the behavior of executed D after H has already
    aborted its simulated of D is one recursive invocation away from
    reality.


    No, I am talkiag about the behavior of D when actually executed.

    Since it has behavior that H didn't simulate, that makes H's simuation
    not correct for the purposes of determining the behavior of the machine.


    You don't seem to understand the difference between the reality of the
    actual execution of the machine, and the make believe world of H's
    simulation which it thinks is "correct" when it isn't.

    Just like you seem to live in a make believe world what H, while just a
    single program, has two different behaviors to the same input.

    There is a name of people who can't face reality and just live in a
    fantasy world.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Fri May 26 00:10:34 2023
    XPost: sci.logic, comp.theory

    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?


    Or is H actually two different programs that you claim to be just one?


    The outer D behaves differently after its own inner D has been aborted
    than the inner D that must be aborted behaves.



    Really, at what instruction is there a difference between the ACTUAL
    EXECUTION of the H(D,D) on the outer level, that called by main, and the
    H(D,D) call be the D(D) that is called by main?

    This has been asked of you, and the answer never provided, because there
    is no point this happens.

    All you are doing is showinfg that you don't understand what a Turing
    Machine actually is and what a correct simulation actually is.

    YOU FAIL.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Fri May 26 00:06:27 2023
    XPost: sci.logic, comp.theory

    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.



    Or is H actually two different programs that you claim to be just one?


    The outer D behaves differently after its own inner D has been aborted
    than the inner D that must be aborted behaves.



    Really, at what instruction is there a difference between the ACTUAL EXECUTION of the H(D,D) on the outer level, that called by main, and the H(D,D) call be the D(D) that is called by main?


    All of the continue to execute


    This has been asked of you, and the answer never provided, because there
    is no point this happens.

    All you are doing is showinfg that you don't understand what a Turing
    Machine actually is and what a correct simulation actually is.

    YOU FAIL.

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Fri May 26 10:55:46 2023
    XPost: sci.logic, comp.theory

    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.

    But since when main calls H(D,D) that doesn't happen, you have just
    admitted that the H that D calls is a different pure function then the H
    that main calls, so you have been lying that D is calling the same pure function H for all these years.

    Glad you have come out and admitted that.

    Or maybe you have just been lying that you have actually done any of
    this, because that isn't what happens when you run D the way you say
    using the exact same H as answers.




    Or is H actually two different programs that you claim to be just one? >>>>

    The outer D behaves differently after its own inner D has been
    aborted than the inner D that must be aborted behaves.



    Really, at what instruction is there a difference between the ACTUAL
    EXECUTION of the H(D,D) on the outer level, that called by main, and
    the H(D,D) call be the D(D) that is called by main?


    All of the continue to execute


    This has been asked of you, and the answer never provided, because
    there is no point this happens.

    All you are doing is showinfg that you don't understand what a Turing
    Machine actually is and what a correct simulation actually is.

    YOU FAIL.


    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Fri May 26 10:51:53 2023
    XPost: sci.logic, comp.theory

    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.

    So, why doesn't that happen when main calls H?

    What instruction in H acts differently because it was called by D
    instead of Main.




    Or is H actually two different programs that you claim to be just one? >>>>

    The outer D behaves differently after its own inner D has been
    aborted than the inner D that must be aborted behaves.



    Really, at what instruction is there a difference between the ACTUAL
    EXECUTION of the H(D,D) on the outer level, that called by main, and
    the H(D,D) call be the D(D) that is called by main?


    All of the continue to execute

    SO? That means that H never stops if both of them just continue to
    execute, so H is not a decider.


    I guess you just don't understand how computers, and computer programs, actually work.

    Or, you are just a pathological liar.



    This has been asked of you, and the answer never provided, because
    there is no point this happens.

    All you are doing is showinfg that you don't understand what a Turing
    Machine actually is and what a correct simulation actually is.

    YOU FAIL.


    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Fri May 26 10:07:59 2023
    XPost: sci.logic, comp.theory

    On 5/26/2023 9:51 AM, Richard Damon wrote:
    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.

    So, why doesn't that happen when main calls  H?


    H does return to its caller when main calls H.

    What instruction in H acts differently because it was called by D
    instead of Main.

    Nothing acts differently in H called with (D,D) no matter what calls it.

    This simulation invariant is always true:
    D correctly simulated by H cannot possibly reach its own line 04

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Fri May 26 11:33:03 2023
    XPost: sci.logic, comp.theory

    On 5/26/23 11:07 AM, olcott wrote:
    On 5/26/2023 9:51 AM, Richard Damon wrote:
    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.

    So, why doesn't that happen when main calls  H?


    H does return to its caller when main calls H.

    So, which instruction acts differently?

    We have two IDENTICAL initial sequence of instructions, the entry to H,
    in one case from main, and in the other from D, with identical parameters.

    If the results follow different paths, there must be a first point of departure. What is it.

    Your inability to understand this just shows you are a total moron in
    reguards to how computer programs work, or it just shows you are a
    pathological liar, insisting on thing you say must be true with
    absolutdly no factual backing, and proof that they can't be.


    What instruction in H acts differently because it was called by D
    instead of Main.

    Nothing acts differently in H called with (D,D) no matter what calls it.

    So, why does one call run forever and the other return?

    You seem to be caught in a lie. In one statement you say the act
    differently, in the other you say that act the same.

    I guess in your fantasy world, same and different are the same, or are
    they different but still the same?


    This simulation invariant is always true:
    D correctly simulated by H cannot possibly reach its own line 04


    So? We aren't talking about the D being simulate by H, but the D called
    by main, whose behavior DEFINES what a "Correct Simulation" would be.

    All you have shown is that no program like H can simulate this form of
    input to a final state, even though, if that H does answer 0, it WILL Halt.

    So, your arguement has just fallen apart and your "proof" is shown to be
    a sham.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From olcott@21:1/5 to Richard Damon on Fri May 26 11:17:42 2023
    XPost: sci.logic, comp.theory

    On 5/26/2023 10:33 AM, Richard Damon wrote:
    On 5/26/23 11:07 AM, olcott wrote:
    On 5/26/2023 9:51 AM, Richard Damon wrote:
    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.

    So, why doesn't that happen when main calls  H?


    H does return to its caller when main calls H.

    So, which instruction acts differently?


    H(D,D) always operates the exact same way no matter what calls it.

    We have two IDENTICAL initial sequence of instructions, the entry to H,
    in one case from main, and in the other from D, with identical parameters.

    If the results follow different paths, there must be a first point of departure. What is it.


    D(D) is merely the outer invocation that includes H(D,D) as the inner invocation. Directly executed H(D,D) always behaves exactly the same
    way whenever it is invoked.

    Because it is an easily verified fact that neither the directly executed
    H(D,D) nor the directly executed D(D) would ever terminate normally
    unless H aborts its simulation of D, H is necessarily correct to abort
    its simulation of D to meet the requirement that itself must halt.

    It is also a tautology that when a simulation must be aborted to prevent
    the simulator's infinite execution that this simulated input does
    specify non-halting behavior to this simulator.

    You can call me all kinds of insults and gullible fools will take these
    insults as rebuttal. The target audience, however, is not gullible
    fools.

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

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Richard Damon@21:1/5 to olcott on Fri May 26 12:51:36 2023
    XPost: sci.logic, comp.theory

    On 5/26/23 12:17 PM, olcott wrote:
    On 5/26/2023 10:33 AM, Richard Damon wrote:
    On 5/26/23 11:07 AM, olcott wrote:
    On 5/26/2023 9:51 AM, Richard Damon wrote:
    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.

    So, why doesn't that happen when main calls  H?


    H does return to its caller when main calls H.

    So, which instruction acts differently?


    H(D,D) always operates the exact same way no matter what calls it.

    We have two IDENTICAL initial sequence of instructions, the entry to
    H, in one case from main, and in the other from D, with identical
    parameters.

    If the results follow different paths, there must be a first point of
    departure. What is it.


    D(D) is merely the outer invocation that includes H(D,D) as the inner invocation. Directly executed H(D,D) always behaves exactly the same
    way whenever it is invoked.

    So, you admit that D(D) will Halt, so, since H(D,D) is asking H to
    decide if D(D) will Halt, it should have answered YES, (1)


    Because it is an easily verified fact that neither the directly executed H(D,D) nor the directly executed D(D) would ever terminate normally
    unless H aborts its simulation of D, H is necessarily correct to abort
    its simulation of D to meet the requirement that itself must halt.

    No it DOES terminate because it DOES abort is simulation, since that is
    what the code says to do. No need to argue about a fantasy case that
    doesn't exist.

    In this problem, there does not exist an H that doesn't abort its
    simulation, that program just doesn't exist here. That would be a
    DIFFERENT program.


    It is also a tautology that when a simulation must be aborted to prevent
    the simulator's infinite execution that this simulated input does
    specify non-halting behavior to this simulator.

    Yes, but that means if you change the simulator, but NOT the input, to
    not abort, it must run forever. Since you can't do that in your broken
    model, that tautology isn't applicable.


    You can call me all kinds of insults and gullible fools will take these insults as rebuttal. The target audience, however, is not gullible
    fools.


    Fine, you are the ignorant pathological lying idiot, and I will continue
    to point out the errors in your logic that your stupid brain can't
    understand so a target audience with any bit of reasoning will
    understand how broken your argument is.

    I am counting on the audience not to be a gullible fools, so am showing
    what the truth actually is.

    Your logic is as bad as Trump's, and only someone as dumb as a Trump
    Supporter would believe your lies.

    I am really coming to the conviction that you are just mentally
    incapable of understanding, and am just limiting the spread of your
    cancerous folly.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)