On 5/27/23 11:59 AM, olcott wrote:
> 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.
>
> Do you understand that when D correctly simulated by H has had
> its simulation aborted by H that this does not count as normal
> termination for D?
>
>

Right, but we aren't asked about D simulated by H, but by what the
MACHINE D does on its own!!!! The Simulation of D stopped, indicating no
conclusive evidence of the final behavior of the machine.

YOU are the only one interested in D (partially) simulated by H.

No where in the problem does it ask about D simulated by H, or even D
simulated at all. Yes, you can use a UTM simulation, but only because
that, by definition, exactly matches the behavior of the machine D.

Since D(D) halts, because it uses its copy of H(D,D) which aborts its
simulation of the representation of D it was given, and then returns 0
to D(D), and then D(D) does halt.

Thus you are just lying when you say the correct answer could be
non-halting, and your stupidity to even think that could be the right
answer even after being shown that D(D) halts.

Your failure to provide ANY reputable source that indicates "A
Simulation by H" as the basis of the Halting Criteria, shows that you
don't actually have any grounds to make the claim.

This is why I can point you and giv eyou the label of an ignorant
pathological lying idiot. You claim as true something you do not
understand, and have been shown to be incorrect.

This indicates that your "Correct Reasoning" idea is likely just as full
of errors and unsound logic.