On 5/26/23 9:33 PM, olcott wrote:
> On 5/26/2023 8:22 PM, Richard Damon wrote:
>> On 5/26/23 9:11 PM, olcott wrote:
>>> On 5/26/2023 7:55 PM, Richard Damon wrote:
>>>> On 5/26/23 8:41 PM, olcott wrote:
>>>>> On 5/26/2023 7:10 PM, Richard Damon wrote:
>>>>>> On 5/26/23 7:50 PM, olcott wrote:
>>>>>>> On 5/26/2023 6:42 PM, Richard Damon wrote:
>>>>>>>> On 5/26/23 7:31 PM, olcott wrote:
>>>>>>>>> On 5/26/2023 11:51 AM, Richard Damon wrote:
>>>>>>>>>> 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.
>>>>>>>>>
>>>>>>>>> *Halting auto problem repair shop analogy*
>>>>>>>>> (a) You take your car to the repair shop.
>>>>>>>>> (b) The car is badly in need of a replacement exhaust system.
>>>>>>>>> (c) You ask the head mechanic to inspect your car's exhaust
>>>>>>>>> system.
>>>>>>>>> (d) The head mechanic tells you it needs to be replaced.
>>>>>>>>> (e) You authorize the head mechanic to replace the exhaust system.
>>>>>>>>> (f) At the checkout counter you accuse the head mechanic of lying
>>>>>>>>>      because your car clearly does not need to have its exhaust
>>>>>>>>> system
>>>>>>>>>      replaced.
>>>>>>>>> (g) You refuse to pay on this basis.
>>>>>>>>> (h) The owner calls the police and they tell you pay up or go
>>>>>>>>> to jail.
>>>>>>>>>
>>>>>>>>> H is asked the question: Does your input need to be aborted to
>>>>>>>>> prevent infinite simulation?  H correctly answers yes and
>>>>>>>>> aborts the simulation.
>>>>>>>>
>>>>>>>> Nope, H is asked the question, does the machine represented by
>>>>>>>> your input finish running in finite time?
>>>>>>>>
>>>>>>> That is asking the question:
>>>>>>> Does my exhaust system need to be replaced after you just
>>>>>>> replaced it?
>>>>>>>
>>>>>>
>>>>>> Why do you say that?
>>>>>>
>>>>> We cannot say that the YES answer original question:
>>>>> (a) Does the exhaust system need to be replaced?
>>>>> (b) Does the simulation need to be aborted?
>>>>
>>>> Except (b) isn't the question of a Halt Decider.
>>>>
>>>> It should be "Does the Machine Described Reach its final state when
>>>> run?"
>>>>
>>>
>>> When your exhaust system needs to be replaced
>>> The question: Does my exhaust system need to be replaced?
>>> has YES as a correct answer.
>>>
>>> We can't say that this answer is wrong on the basis that the
>>> answer changes to NO *After the exhaust system has been replaced*
>>>
>>> When we ask Does the input to H terminate normally?
>>> the answer is always NO.
>>
>> Which ISN'T the question!, and your repeating that just shows you to
>> be a LIAR. NO ONE (except you) is interested in your question.
>>
>> As you have posted before, from
>> https://en.wikipedia.org/wiki/Halting_problem
>>
>> In computability theory, the halting problem is the problem of
>> determining, from a description of an arbitrary computer program and
>> an input, whether the program will finish running, or continue to run
>> forever.
>>
>
> We can't say that D(D) halts on the basis that its otherwise infinite
> simulation has already been aborted.

On 5/26/2023 8:53 PM, Richard Damon wrote:
> On 5/26/23 9:33 PM, olcott wrote:
>> On 5/26/2023 8:22 PM, Richard Damon wrote:
>>> On 5/26/23 9:11 PM, olcott wrote:
>>>> On 5/26/2023 7:55 PM, Richard Damon wrote:
>>>>> On 5/26/23 8:41 PM, olcott wrote:
>>>>>> On 5/26/2023 7:10 PM, Richard Damon wrote:
>>>>>>> On 5/26/23 7:50 PM, olcott wrote:
>>>>>>>> On 5/26/2023 6:42 PM, Richard Damon wrote:
>>>>>>>>> On 5/26/23 7:31 PM, olcott wrote:
>>>>>>>>>> On 5/26/2023 11:51 AM, Richard Damon wrote:
>>>>>>>>>>> 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.
>>>>>>>>>>
>>>>>>>>>> *Halting auto problem repair shop analogy*
>>>>>>>>>> (a) You take your car to the repair shop.
>>>>>>>>>> (b) The car is badly in need of a replacement exhaust system.
>>>>>>>>>> (c) You ask the head mechanic to inspect your car's exhaust
>>>>>>>>>> system.
>>>>>>>>>> (d) The head mechanic tells you it needs to be replaced.
>>>>>>>>>> (e) You authorize the head mechanic to replace the exhaust
>>>>>>>>>> system.
>>>>>>>>>> (f) At the checkout counter you accuse the head mechanic of lying
>>>>>>>>>>      because your car clearly does not need to have its
>>>>>>>>>> exhaust system
>>>>>>>>>>      replaced.
>>>>>>>>>> (g) You refuse to pay on this basis.
>>>>>>>>>> (h) The owner calls the police and they tell you pay up or go
>>>>>>>>>> to jail.
>>>>>>>>>>
>>>>>>>>>> H is asked the question: Does your input need to be aborted to
>>>>>>>>>> prevent infinite simulation?  H correctly answers yes and
>>>>>>>>>> aborts the simulation.
>>>>>>>>>
>>>>>>>>> Nope, H is asked the question, does the machine represented by
>>>>>>>>> your input finish running in finite time?
>>>>>>>>>
>>>>>>>> That is asking the question:
>>>>>>>> Does my exhaust system need to be replaced after you just
>>>>>>>> replaced it?
>>>>>>>>
>>>>>>>
>>>>>>> Why do you say that?
>>>>>>>
>>>>>> We cannot say that the YES answer original question:
>>>>>> (a) Does the exhaust system need to be replaced?
>>>>>> (b) Does the simulation need to be aborted?
>>>>>
>>>>> Except (b) isn't the question of a Halt Decider.
>>>>>
>>>>> It should be "Does the Machine Described Reach its final state when
>>>>> run?"
>>>>>
>>>>
>>>> When your exhaust system needs to be replaced
>>>> The question: Does my exhaust system need to be replaced?
>>>> has YES as a correct answer.
>>>>
>>>> We can't say that this answer is wrong on the basis that the
>>>> answer changes to NO *After the exhaust system has been replaced*
>>>>
>>>> When we ask Does the input to H terminate normally?
>>>> the answer is always NO.
>>>
>>> Which ISN'T the question!, and your repeating that just shows you to
>>> be a LIAR. NO ONE (except you) is interested in your question.
>>>
>>> As you have posted before, from
>>> https://en.wikipedia.org/wiki/Halting_problem
>>>
>>> In computability theory, the halting problem is the problem of
>>> determining, from a description of an arbitrary computer program and
>>> an input, whether the program will finish running, or continue to run
>>> forever.
>>>
>>
>> We can't say that D(D) halts on the basis that its otherwise infinite
>> simulation has already been aborted.
>
> No, we say it halts because when we run it with the H that you have
> defined to return 0 when asked H(D,D), it halts.
>
> No one is asking about a simulation.
>
> Your problem is you forget that H has been defined as a specific
> program. You H DOES abort at a specific point, and something that does
> something different is a different program.
>
> Maybe you just don't understand that a program is what it has actually
> been programmed to be. Maybe you lost your job as a programmer because
> you don't actually understand what a program is.
>
>>
>> This is exactly the same thing as saying that the mechanic lied about
>> your car needing a new exhaust system because it doesn't need one after
>> it has been replaced.
>>
>
> Nope, YOU are the one lying.
>
> H DOES abort its simulation and returns 0 to D(D) which makes it halt.
>
>
> Do you deny that? That is what you program shows.
>

On 5/26/23 9:58 PM, olcott wrote:
> On 5/26/2023 8:53 PM, Richard Damon wrote:
>> On 5/26/23 9:33 PM, olcott wrote:
>>> On 5/26/2023 8:22 PM, Richard Damon wrote:
>>>> On 5/26/23 9:11 PM, olcott wrote:
>>>>> On 5/26/2023 7:55 PM, Richard Damon wrote:
>>>>>> On 5/26/23 8:41 PM, olcott wrote:
>>>>>>> On 5/26/2023 7:10 PM, Richard Damon wrote:
>>>>>>>> On 5/26/23 7:50 PM, olcott wrote:
>>>>>>>>> On 5/26/2023 6:42 PM, Richard Damon wrote:
>>>>>>>>>> On 5/26/23 7:31 PM, olcott wrote:
>>>>>>>>>>> On 5/26/2023 11:51 AM, Richard Damon wrote:
>>>>>>>>>>>> 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.
>>>>>>>>>>>
>>>>>>>>>>> *Halting auto problem repair shop analogy*
>>>>>>>>>>> (a) You take your car to the repair shop.
>>>>>>>>>>> (b) The car is badly in need of a replacement exhaust system.
>>>>>>>>>>> (c) You ask the head mechanic to inspect your car's exhaust
>>>>>>>>>>> system.
>>>>>>>>>>> (d) The head mechanic tells you it needs to be replaced.
>>>>>>>>>>> (e) You authorize the head mechanic to replace the exhaust
>>>>>>>>>>> system.
>>>>>>>>>>> (f) At the checkout counter you accuse the head mechanic of
>>>>>>>>>>> lying
>>>>>>>>>>>      because your car clearly does not need to have its
>>>>>>>>>>> exhaust system
>>>>>>>>>>>      replaced.
>>>>>>>>>>> (g) You refuse to pay on this basis.
>>>>>>>>>>> (h) The owner calls the police and they tell you pay up or go
>>>>>>>>>>> to jail.
>>>>>>>>>>>
>>>>>>>>>>> H is asked the question: Does your input need to be aborted
>>>>>>>>>>> to prevent infinite simulation?  H correctly answers yes and
>>>>>>>>>>> aborts the simulation.
>>>>>>>>>>
>>>>>>>>>> Nope, H is asked the question, does the machine represented by
>>>>>>>>>> your input finish running in finite time?
>>>>>>>>>>
>>>>>>>>> That is asking the question:
>>>>>>>>> Does my exhaust system need to be replaced after you just
>>>>>>>>> replaced it?
>>>>>>>>>
>>>>>>>>
>>>>>>>> Why do you say that?
>>>>>>>>
>>>>>>> We cannot say that the YES answer original question:
>>>>>>> (a) Does the exhaust system need to be replaced?
>>>>>>> (b) Does the simulation need to be aborted?
>>>>>>
>>>>>> Except (b) isn't the question of a Halt Decider.
>>>>>>
>>>>>> It should be "Does the Machine Described Reach its final state
>>>>>> when run?"
>>>>>>
>>>>>
>>>>> When your exhaust system needs to be replaced
>>>>> The question: Does my exhaust system need to be replaced?
>>>>> has YES as a correct answer.
>>>>>
>>>>> We can't say that this answer is wrong on the basis that the
>>>>> answer changes to NO *After the exhaust system has been replaced*
>>>>>
>>>>> When we ask Does the input to H terminate normally?
>>>>> the answer is always NO.
>>>>
>>>> Which ISN'T the question!, and your repeating that just shows you to
>>>> be a LIAR. NO ONE (except you) is interested in your question.
>>>>
>>>> As you have posted before, from
>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>
>>>> In computability theory, the halting problem is the problem of
>>>> determining, from a description of an arbitrary computer program and
>>>> an input, whether the program will finish running, or continue to
>>>> run forever.
>>>>
>>>
>>> We can't say that D(D) halts on the basis that its otherwise infinite
>>> simulation has already been aborted.
>>
>> No, we say it halts because when we run it with the H that you have
>> defined to return 0 when asked H(D,D), it halts.
>>
>> No one is asking about a simulation.
>>
>> Your problem is you forget that H has been defined as a specific
>> program. You H DOES abort at a specific point, and something that does
>> something different is a different program.
>>
>> Maybe you just don't understand that a program is what it has actually
>> been programmed to be. Maybe you lost your job as a programmer because
>> you don't actually understand what a program is.
>>
>>>
>>> This is exactly the same thing as saying that the mechanic lied about
>>> your car needing a new exhaust system because it doesn't need one after
>>> it has been replaced.
>>>
>>
>> Nope, YOU are the one lying.
>>
>> H DOES abort its simulation and returns 0 to D(D) which makes it halt.
>>
>>
>> Do you deny that? That is what you program shows.
>>
>
> So you deny that D(D) would never stop running unless H(D,D) does abort
> its simulation?
>

On 5/26/2023 9:02 PM, Richard Damon wrote:
> On 5/26/23 9:58 PM, olcott wrote:
>> On 5/26/2023 8:53 PM, Richard Damon wrote:
>>> On 5/26/23 9:33 PM, olcott wrote:
>>>> On 5/26/2023 8:22 PM, Richard Damon wrote:
>>>>> On 5/26/23 9:11 PM, olcott wrote:
>>>>>> On 5/26/2023 7:55 PM, Richard Damon wrote:
>>>>>>> On 5/26/23 8:41 PM, olcott wrote:
>>>>>>>> On 5/26/2023 7:10 PM, Richard Damon wrote:
>>>>>>>>> On 5/26/23 7:50 PM, olcott wrote:
>>>>>>>>>> On 5/26/2023 6:42 PM, Richard Damon wrote:
>>>>>>>>>>> On 5/26/23 7:31 PM, olcott wrote:
>>>>>>>>>>>> On 5/26/2023 11:51 AM, Richard Damon wrote:
>>>>>>>>>>>>> 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.
>>>>>>>>>>>>
>>>>>>>>>>>> *Halting auto problem repair shop analogy*
>>>>>>>>>>>> (a) You take your car to the repair shop.
>>>>>>>>>>>> (b) The car is badly in need of a replacement exhaust system.
>>>>>>>>>>>> (c) You ask the head mechanic to inspect your car's exhaust
>>>>>>>>>>>> system.
>>>>>>>>>>>> (d) The head mechanic tells you it needs to be replaced.
>>>>>>>>>>>> (e) You authorize the head mechanic to replace the exhaust
>>>>>>>>>>>> system.
>>>>>>>>>>>> (f) At the checkout counter you accuse the head mechanic of
>>>>>>>>>>>> lying
>>>>>>>>>>>>      because your car clearly does not need to have its
>>>>>>>>>>>> exhaust system
>>>>>>>>>>>>      replaced.
>>>>>>>>>>>> (g) You refuse to pay on this basis.
>>>>>>>>>>>> (h) The owner calls the police and they tell you pay up or
>>>>>>>>>>>> go to jail.
>>>>>>>>>>>>
>>>>>>>>>>>> H is asked the question: Does your input need to be aborted
>>>>>>>>>>>> to prevent infinite simulation?  H correctly answers yes and
>>>>>>>>>>>> aborts the simulation.
>>>>>>>>>>>
>>>>>>>>>>> Nope, H is asked the question, does the machine represented
>>>>>>>>>>> by your input finish running in finite time?
>>>>>>>>>>>
>>>>>>>>>> That is asking the question:
>>>>>>>>>> Does my exhaust system need to be replaced after you just
>>>>>>>>>> replaced it?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Why do you say that?
>>>>>>>>>
>>>>>>>> We cannot say that the YES answer original question:
>>>>>>>> (a) Does the exhaust system need to be replaced?
>>>>>>>> (b) Does the simulation need to be aborted?
>>>>>>>
>>>>>>> Except (b) isn't the question of a Halt Decider.
>>>>>>>
>>>>>>> It should be "Does the Machine Described Reach its final state
>>>>>>> when run?"
>>>>>>>
>>>>>>
>>>>>> When your exhaust system needs to be replaced
>>>>>> The question: Does my exhaust system need to be replaced?
>>>>>> has YES as a correct answer.
>>>>>>
>>>>>> We can't say that this answer is wrong on the basis that the
>>>>>> answer changes to NO *After the exhaust system has been replaced*
>>>>>>
>>>>>> When we ask Does the input to H terminate normally?
>>>>>> the answer is always NO.
>>>>>
>>>>> Which ISN'T the question!, and your repeating that just shows you
>>>>> to be a LIAR. NO ONE (except you) is interested in your question.
>>>>>
>>>>> As you have posted before, from
>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>
>>>>> In computability theory, the halting problem is the problem of
>>>>> determining, from a description of an arbitrary computer program
>>>>> and an input, whether the program will finish running, or continue
>>>>> to run forever.
>>>>>
>>>>
>>>> We can't say that D(D) halts on the basis that its otherwise infinite
>>>> simulation has already been aborted.
>>>
>>> No, we say it halts because when we run it with the H that you have
>>> defined to return 0 when asked H(D,D), it halts.
>>>
>>> No one is asking about a simulation.
>>>
>>> Your problem is you forget that H has been defined as a specific
>>> program. You H DOES abort at a specific point, and something that
>>> does something different is a different program.
>>>
>>> Maybe you just don't understand that a program is what it has
>>> actually been programmed to be. Maybe you lost your job as a
>>> programmer because you don't actually understand what a program is.
>>>
>>>>
>>>> This is exactly the same thing as saying that the mechanic lied about
>>>> your car needing a new exhaust system because it doesn't need one after
>>>> it has been replaced.
>>>>
>>>
>>> Nope, YOU are the one lying.
>>>
>>> H DOES abort its simulation and returns 0 to D(D) which makes it halt.
>>>
>>>
>>> Do you deny that? That is what you program shows.
>>>
>>
>> So you deny that D(D) would never stop running unless H(D,D) does
>> abort its simulation?
>>
>
> No, D(D) stops running because the H(D,D) that it calls DOES abort its
> simmulation and returns the value 0 to it.
>

On 5/26/23 10:06 PM, olcott wrote:
> On 5/26/2023 9:02 PM, Richard Damon wrote:
>> On 5/26/23 9:58 PM, olcott wrote:
>>> On 5/26/2023 8:53 PM, Richard Damon wrote:
>>>> On 5/26/23 9:33 PM, olcott wrote:
>>>>> On 5/26/2023 8:22 PM, Richard Damon wrote:
>>>>>> On 5/26/23 9:11 PM, olcott wrote:
>>>>>>> On 5/26/2023 7:55 PM, Richard Damon wrote:
>>>>>>>> On 5/26/23 8:41 PM, olcott wrote:
>>>>>>>>> On 5/26/2023 7:10 PM, Richard Damon wrote:
>>>>>>>>>> On 5/26/23 7:50 PM, olcott wrote:
>>>>>>>>>>> On 5/26/2023 6:42 PM, Richard Damon wrote:
>>>>>>>>>>>> On 5/26/23 7:31 PM, olcott wrote:
>>>>>>>>>>>>> On 5/26/2023 11:51 AM, Richard Damon wrote:
>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Halting auto problem repair shop analogy*
>>>>>>>>>>>>> (a) You take your car to the repair shop.
>>>>>>>>>>>>> (b) The car is badly in need of a replacement exhaust system.
>>>>>>>>>>>>> (c) You ask the head mechanic to inspect your car's exhaust
>>>>>>>>>>>>> system.
>>>>>>>>>>>>> (d) The head mechanic tells you it needs to be replaced.
>>>>>>>>>>>>> (e) You authorize the head mechanic to replace the exhaust
>>>>>>>>>>>>> system.
>>>>>>>>>>>>> (f) At the checkout counter you accuse the head mechanic of
>>>>>>>>>>>>> lying
>>>>>>>>>>>>>      because your car clearly does not need to have its
>>>>>>>>>>>>> exhaust system
>>>>>>>>>>>>>      replaced.
>>>>>>>>>>>>> (g) You refuse to pay on this basis.
>>>>>>>>>>>>> (h) The owner calls the police and they tell you pay up or
>>>>>>>>>>>>> go to jail.
>>>>>>>>>>>>>
>>>>>>>>>>>>> H is asked the question: Does your input need to be aborted
>>>>>>>>>>>>> to prevent infinite simulation?  H correctly answers yes
>>>>>>>>>>>>> and aborts the simulation.
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, H is asked the question, does the machine represented
>>>>>>>>>>>> by your input finish running in finite time?
>>>>>>>>>>>>
>>>>>>>>>>> That is asking the question:
>>>>>>>>>>> Does my exhaust system need to be replaced after you just
>>>>>>>>>>> replaced it?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Why do you say that?
>>>>>>>>>>
>>>>>>>>> We cannot say that the YES answer original question:
>>>>>>>>> (a) Does the exhaust system need to be replaced?
>>>>>>>>> (b) Does the simulation need to be aborted?
>>>>>>>>
>>>>>>>> Except (b) isn't the question of a Halt Decider.
>>>>>>>>
>>>>>>>> It should be "Does the Machine Described Reach its final state
>>>>>>>> when run?"
>>>>>>>>
>>>>>>>
>>>>>>> When your exhaust system needs to be replaced
>>>>>>> The question: Does my exhaust system need to be replaced?
>>>>>>> has YES as a correct answer.
>>>>>>>
>>>>>>> We can't say that this answer is wrong on the basis that the
>>>>>>> answer changes to NO *After the exhaust system has been replaced*
>>>>>>>
>>>>>>> When we ask Does the input to H terminate normally?
>>>>>>> the answer is always NO.
>>>>>>
>>>>>> Which ISN'T the question!, and your repeating that just shows you
>>>>>> to be a LIAR. NO ONE (except you) is interested in your question.
>>>>>>
>>>>>> As you have posted before, from
>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>
>>>>>> In computability theory, the halting problem is the problem of
>>>>>> determining, from a description of an arbitrary computer program
>>>>>> and an input, whether the program will finish running, or continue
>>>>>> to run forever.
>>>>>>
>>>>>
>>>>> We can't say that D(D) halts on the basis that its otherwise infinite
>>>>> simulation has already been aborted.
>>>>
>>>> No, we say it halts because when we run it with the H that you have
>>>> defined to return 0 when asked H(D,D), it halts.
>>>>
>>>> No one is asking about a simulation.
>>>>
>>>> Your problem is you forget that H has been defined as a specific
>>>> program. You H DOES abort at a specific point, and something that
>>>> does something different is a different program.
>>>>
>>>> Maybe you just don't understand that a program is what it has
>>>> actually been programmed to be. Maybe you lost your job as a
>>>> programmer because you don't actually understand what a program is.
>>>>
>>>>>
>>>>> This is exactly the same thing as saying that the mechanic lied about
>>>>> your car needing a new exhaust system because it doesn't need one
>>>>> after
>>>>> it has been replaced.
>>>>>
>>>>
>>>> Nope, YOU are the one lying.
>>>>
>>>> H DOES abort its simulation and returns 0 to D(D) which makes it halt.
>>>>
>>>>
>>>> Do you deny that? That is what you program shows.
>>>>
>>>
>>> So you deny that D(D) would never stop running unless H(D,D) does
>>> abort its simulation?
>>>
>>
>> No, D(D) stops running because the H(D,D) that it calls DOES abort its
>> simmulation and returns the value 0 to it.
>>
>
> In the hypothetical case where H(D,D) never aborts its simulation does
> D(D) ever terminate normally?
>
>

On 5/27/2023 7:12 AM, Richard Damon wrote:
> On 5/26/23 10:06 PM, olcott wrote:
>> On 5/26/2023 9:02 PM, Richard Damon wrote:
>>> On 5/26/23 9:58 PM, olcott wrote:
>>>> On 5/26/2023 8:53 PM, Richard Damon wrote:
>>>>> On 5/26/23 9:33 PM, olcott wrote:
>>>>>> On 5/26/2023 8:22 PM, Richard Damon wrote:
>>>>>>> On 5/26/23 9:11 PM, olcott wrote:
>>>>>>>> On 5/26/2023 7:55 PM, Richard Damon wrote:
>>>>>>>>> On 5/26/23 8:41 PM, olcott wrote:
>>>>>>>>>> On 5/26/2023 7:10 PM, Richard Damon wrote:
>>>>>>>>>>> On 5/26/23 7:50 PM, olcott wrote:
>>>>>>>>>>>> On 5/26/2023 6:42 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 5/26/23 7:31 PM, olcott wrote:
>>>>>>>>>>>>>> On 5/26/2023 11:51 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *Halting auto problem repair shop analogy*
>>>>>>>>>>>>>> (a) You take your car to the repair shop.
>>>>>>>>>>>>>> (b) The car is badly in need of a replacement exhaust system.
>>>>>>>>>>>>>> (c) You ask the head mechanic to inspect your car's
>>>>>>>>>>>>>> exhaust system.
>>>>>>>>>>>>>> (d) The head mechanic tells you it needs to be replaced.
>>>>>>>>>>>>>> (e) You authorize the head mechanic to replace the exhaust
>>>>>>>>>>>>>> system.
>>>>>>>>>>>>>> (f) At the checkout counter you accuse the head mechanic
>>>>>>>>>>>>>> of lying
>>>>>>>>>>>>>>      because your car clearly does not need to have its
>>>>>>>>>>>>>> exhaust system
>>>>>>>>>>>>>>      replaced.
>>>>>>>>>>>>>> (g) You refuse to pay on this basis.
>>>>>>>>>>>>>> (h) The owner calls the police and they tell you pay up or
>>>>>>>>>>>>>> go to jail.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H is asked the question: Does your input need to be
>>>>>>>>>>>>>> aborted to prevent infinite simulation?  H correctly
>>>>>>>>>>>>>> answers yes and aborts the simulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope, H is asked the question, does the machine represented
>>>>>>>>>>>>> by your input finish running in finite time?
>>>>>>>>>>>>>
>>>>>>>>>>>> That is asking the question:
>>>>>>>>>>>> Does my exhaust system need to be replaced after you just
>>>>>>>>>>>> replaced it?
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Why do you say that?
>>>>>>>>>>>
>>>>>>>>>> We cannot say that the YES answer original question:
>>>>>>>>>> (a) Does the exhaust system need to be replaced?
>>>>>>>>>> (b) Does the simulation need to be aborted?
>>>>>>>>>
>>>>>>>>> Except (b) isn't the question of a Halt Decider.
>>>>>>>>>
>>>>>>>>> It should be "Does the Machine Described Reach its final state
>>>>>>>>> when run?"
>>>>>>>>>
>>>>>>>>
>>>>>>>> When your exhaust system needs to be replaced
>>>>>>>> The question: Does my exhaust system need to be replaced?
>>>>>>>> has YES as a correct answer.
>>>>>>>>
>>>>>>>> We can't say that this answer is wrong on the basis that the
>>>>>>>> answer changes to NO *After the exhaust system has been replaced*
>>>>>>>>
>>>>>>>> When we ask Does the input to H terminate normally?
>>>>>>>> the answer is always NO.
>>>>>>>
>>>>>>> Which ISN'T the question!, and your repeating that just shows you
>>>>>>> to be a LIAR. NO ONE (except you) is interested in your question.
>>>>>>>
>>>>>>> As you have posted before, from
>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>
>>>>>>> In computability theory, the halting problem is the problem of
>>>>>>> determining, from a description of an arbitrary computer program
>>>>>>> and an input, whether the program will finish running, or
>>>>>>> continue to run forever.
>>>>>>>
>>>>>>
>>>>>> We can't say that D(D) halts on the basis that its otherwise infinite
>>>>>> simulation has already been aborted.
>>>>>
>>>>> No, we say it halts because when we run it with the H that you have
>>>>> defined to return 0 when asked H(D,D), it halts.
>>>>>
>>>>> No one is asking about a simulation.
>>>>>
>>>>> Your problem is you forget that H has been defined as a specific
>>>>> program. You H DOES abort at a specific point, and something that
>>>>> does something different is a different program.
>>>>>
>>>>> Maybe you just don't understand that a program is what it has
>>>>> actually been programmed to be. Maybe you lost your job as a
>>>>> programmer because you don't actually understand what a program is.
>>>>>
>>>>>>
>>>>>> This is exactly the same thing as saying that the mechanic lied about
>>>>>> your car needing a new exhaust system because it doesn't need one
>>>>>> after
>>>>>> it has been replaced.
>>>>>>
>>>>>
>>>>> Nope, YOU are the one lying.
>>>>>
>>>>> H DOES abort its simulation and returns 0 to D(D) which makes it halt.
>>>>>
>>>>>
>>>>> Do you deny that? That is what you program shows.
>>>>>
>>>>
>>>> So you deny that D(D) would never stop running unless H(D,D) does
>>>> abort its simulation?
>>>>
>>>
>>> No, D(D) stops running because the H(D,D) that it calls DOES abort
>>> its simmulation and returns the value 0 to it.
>>>
>>
>> In the hypothetical case where H(D,D) never aborts its simulation does
>> D(D) ever terminate normally?
>>
>>
>
> No, but in that Hypothetical case H(D,D) never gives an answer so fails
> too.