On 5/5/2022 9:50 PM, Dennis Bush wrote:
> On Thursday, May 5, 2022 at 10:34:02 PM UTC-4, olcott wrote:
>> On 5/5/2022 9:18 PM, Dennis Bush wrote:
>>> On Thursday, May 5, 2022 at 10:08:31 PM UTC-4, olcott wrote:
>>>> On 5/5/2022 8:59 PM, Dennis Bush wrote:
>>>>> On Thursday, May 5, 2022 at 9:36:41 PM UTC-4, olcott wrote:
>>>>>> On 5/5/2022 8:17 PM, Dennis Bush wrote:
>>>>>>> On Thursday, May 5, 2022 at 9:06:12 PM UTC-4, olcott wrote:
>>>>>>>> On 5/5/2022 5:42 PM, Dennis Bush wrote:
>>>>>>>>> On Thursday, May 5, 2022 at 6:28:10 PM UTC-4, olcott wrote:
>>>>>>>>>> On 5/5/2022 5:06 PM, Dennis Bush wrote:
>>>>>>>>>>> On Thursday, May 5, 2022 at 5:47:07 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 5/5/2022 1:52 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Thursday, May 5, 2022 at 2:39:16 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 5/5/2022 12:28 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Thursday, May 5, 2022 at 1:17:38 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 5/5/2022 7:27 AM, Malcolm McLean wrote:
>>>>>>>>>>>>>>>>> On Thursday, 5 May 2022 at 12:54:54 UTC+1, richar...@gmail.com wrote:
>>>>>>>>>>>>>>>>>> On 5/4/22 11:54 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 5/4/2022 10:43 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>> On Wednesday, May 4, 2022 at 11:38:54 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 5/4/2022 10:20 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>> On Wednesday, May 4, 2022 at 11:09:35 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 5/4/2022 9:59 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, May 4, 2022 at 10:55:07 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 5/4/2022 9:28 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/4/2022 7:59 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/4/2022 9:16 AM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/2/2022 6:10 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/2/2022 11:39 AM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is clear that the input to H(P,P) specifies
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely nested
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation to H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What two pointers must be passed to H for H to tell up
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of P(P)? If H can't report on the halting of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation P(P) it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not a halt decider, and you have already told use that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) == false
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and that P(P) halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H can report on the halting of non-input P(P) then it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is not a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider because deciders only compute the mapping from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs to final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> states.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TM deciders compute mappings from inputs to final states
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /according to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some property of the inputs/
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That par is exactly correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> -- whether the input represents, for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That part has been the key error of everyone in that they
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all believe
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that is can represent something other than what it actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So now, after thinking otherwise for years, you claim that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> there is no
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> way to even specify the computation P(P) for you pseudo-C
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H. At least that is a clear admission that the halting of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> function
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls like P(P) can not be decided because, apparently,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> passing P and P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H does not specify that computation, and you can't say
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what two
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> arguments /would/ specify it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A clear and unambiguous statement that no D such that D(X,Y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> == true if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and only if X(Y) halts and false otherwise is possible would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> honest way to move things on. If you were clear about this,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> maybe
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> someone will talk to you about [whatever] it is that your H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> deciding.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you won't admit that no algorithm can do what D is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> specified to do?
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just going to pretend that no one cares about actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> I hope you see that by ignoring this point you are confirming
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you
>>>>>>>>>>>>>>>>>>>>>>>>>>>> know D can't exist. If you thought such a D was possible,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> you'd be
>>>>>>>>>>>>>>>>>>>>>>>>>>>> shouting that from the roof tops since it's what everyone else
>>>>>>>>>>>>>>>>>>>>>>>>>>>> says is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> impossible.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I adapted my system so that I could empirically test this:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H1(P,P)==true is empirically proven to be correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==false is empirically proven to be correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> But neither can tell us squat about the halting of P(P) -- the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> thing
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H was originally supposed to decide.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Are you simply wired to ignore my words so that you can
>>>>>>>>>>>>>>>>>>>>>>>>>>> disagree with
>>>>>>>>>>>>>>>>>>>>>>>>>>> everything that I say?
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> H1(P,P)==true reports on the behavior of P(P).
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> I try to ignore that bits that are irrelevant. These two deciders
>>>>>>>>>>>>>>>>>>>>>>>>>> decide all halting instances between them:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> bool H1(X, Y) { return true; }
>>>>>>>>>>>>>>>>>>>>>>>>>> bool H2(X, Y) { return false; }
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Neither is interesting. For H1, the key case is H1(H1_hat,
>>>>>>>>>>>>>>>>>>>>>>>>>> H1_hat) or
>>>>>>>>>>>>>>>>>>>>>>>>>> maybe you call it H1(P1,P1) now since P is what you used to call
>>>>>>>>>>>>>>>>>>>>>>>>>> H_hat.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> H1(P,P)==true is empirically proven to be correct
>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==false is empirically proven to be correct
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> If that is so then H and H1 don't perform the same mapping. This
>>>>>>>>>>>>>>>>>>>>>>>> means that one (or both) do not compute the halting function.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So which one doesn't compute the halting function?
>>>>>>>>>>>>>>>>>>>>>>> *ALL THESE THINGS ARE EASILY VERIFIABLE FACTS*
>>>>>>>>>>>>>>>>>>>>>>> Both take the machine code of P as input parameters and are provably
>>>>>>>>>>>>>>>>>>>>>>> correct simulations of this same input yet one correctly determines
>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>> its input halts and the other correctly determines that its input does
>>>>>>>>>>>>>>>>>>>>>>> not halt.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Which means at least one is not computing the halting function. So
>>>>>>>>>>>>>>>>>>>>>> which one is it?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The above paragraph means that it makes no mistakes in computing the
>>>>>>>>>>>>>>>>>>>>> halting function. This is a verifiable fact, not any mere opinion. The
>>>>>>>>>>>>>>>>>>>>> reason that I did the HP in C/x86 was so that every detail can be shown
>>>>>>>>>>>>>>>>>>>>> thus gaps in reasoning revealed.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Any decider that maps the halting function performs the *same* mapping
>>>>>>>>>>>>>>>>>>>> of inputs to outputs.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> That is now proven to be factually incorrect.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If the above paragraph is proven to be a fact then this proves that both
>>>>>>>>>>>>>>>>>>> H and H1 compute the halting function correctly. The above paragraph can
>>>>>>>>>>>>>>>>>>> be proven to be a fact.
>>>>>>>>>>>>>>>>>> Yes, IF you can prove that cats are dogs, you can prove that H is
>>>>>>>>>>>>>>>>>> correctly computing the Halting Function.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Since you can't, you can't.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> In fact, you have just proven that you don't know what you are talking
>>>>>>>>>>>>>>>>>> about, since you just asserted a LIE.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Two machines claiming to compute the same function must generate the
>>>>>>>>>>>>>>>>>> same answer from the same input or one of them is incorrect.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> BASIC FACT.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> In parapsychology, there's something called "the experimenter effect". The same
>>>>>>>>>>>>>>>>> experiment will show a parapsychological effect or not, depending on who is
>>>>>>>>>>>>>>>>> performing the experiment. This has been described as parapsychology's one finding.
>>>>>>>>>>>>>>>>> If true in an interesting way, it also strikes at the heart of the scientific method.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But intuitively, it's not implausible that an experiment would "work" for an experimenter
>>>>>>>>>>>>>>>>> with gypsy blood, for example. You can't simply reject the experimenter effect on the
>>>>>>>>>>>>>>>>> basis that, if it means more than that certain experimenters are more gullible than
>>>>>>>>>>>>>>>>> others, it leaves the rest of science in tatters.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> PO says that a machine has one behaviour when run, and another behaviour when
>>>>>>>>>>>>>>>>> "correctly simulated". That claim, if true, similarly leaves the whole of computer science
>>>>>>>>>>>>>>>>> in tatters. Which means that it's his responsibility to provide a much better explanation
>>>>>>>>>>>>>>>>> of what he means than he has done currently.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But he's been clear about this. He's asserting what anyone who knows just a tiny amount
>>>>>>>>>>>>>>>>> about computers must consdier to be nonsense. At first glance. But the idea that
>>>>>>>>>>>>>>>>> i^2 = j^2 = k^2 = -1 whilst ijk also = -1 also seems like nonsense at first glance. The
>>>>>>>>>>>>>>>>> difference is that more details were forthcoming.
>>>>>>>>>>>>>>>> Anyone knowing the x86 language can verify that H(P,P) and H1(P,P)
>>>>>>>>>>>>>>>> compute the mapping from their input parameters to their own final state
>>>>>>>>>>>>>>>> correctly. Arguing with verified facts is a fools folly.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So in other words, a decider is always correct about what it's own input does.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes this is an easily verified fact on the basis of the execution trace
>>>>>>>>>>>>>> derived from the correct simulation of its input parameters.
>>>>>>>>>>>>>>> If you believe that to be true, then you also believe that anyone knowing the x86 language can verify that Ha3(N,5) correctly computes the mapping from its input to a non-halting state.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H2(Ha3,N,5) would get the correct halt status for Ha3.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> From what I recall Ha3(N,5) is merely a computation that was defined to
>>>>>>>>>>>>>> make sure it gets the wrong answer. If you disagree then remind me again
>>>>>>>>>>>>>> what it means.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ha3 uses as its abort criteria any computation that proceeds for more that 3 steps.
>>>>>>>>>>>> WHAT ARE YOU NUTS ???
>>>>>>>>>>>>
>>>>>>>>>>>> Trying to push total bullshit likes this proves that you are only a
>>>>>>>>>>>> troll playing head games and an honest dialogue is the last thing on
>>>>>>>>>>>> your mind.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Not at all, I'm just illustrating the flaws in your logic, as you can't show that Ha3 is wrong without also showing that H is also wrong....
>>>>>>>>>>>
>>>>>>>>>>>> A halt decider must simulate its input until it can prove that the
>>>>>>>>>>>> simulation would never end.
>>>>>>>>>>>
>>>>>>>>>>> ... just like this.
>>>>>>>>>>>
>>>>>>>>>>> What you states above is sufficient to show that Ha3(N,5) is not correct to abort, and Ha7(N,5) simulating to a final state and reporting halting proves that Ha3 didn't simulate for long enough.
>>>>>>>>>> OK finally back to an honest dialogue.
>>>>>>>>>
>>>>>>>>> It always was. You're apparently unable to see where I was going with this.
>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Now let's apply that to H(P,P).
>>>>>>>>>>>
>>>>>>>>>>> H(P,P) is not correct to abort, and H1(P,P) simulating to a final state and reporting halting proves that H didn't simulate for long enough.
>>>>>>>>>>>
>>>>>>>>>>> Therefore H(P,P) == false is provable INCORRECT.
>>>>>>>>>> It is easily proven on the basis of verified facts that H(P,P) and
>>>>>>>>>> H1(P,P) do correctly compute the halt function for their input parameters.
>>>>>>>>>
>>>>>>>>> You don't seem to understand. H1 proves that H is wrong
>>>>>>>> Both H(P,P) and H1(P,P) correctly compute the mapping from their input
>>>>>>>> parameters to the halt status specified by these inputs.
>>>>>>>
>>>>>>> FALSE. Remember, you said:
>>>>>>>
>>>>>>> A halt decider must simulate its input until it can prove that the simulation would never end.
>>>>>>>
>>>>>>> Proving that the simulation would never end means that NO simulator can simulate that input to a final state.
>>>>>> You continue to believe that your imagination overrules verified facts:
>>>>>>
>>>>>> That the correct simulation of the input to H(P,P) provably would never
>>>>>> end conclusively proves that H(P,P)==false is correct.
>>>>>
>>>>> It is a verified fact that H(P,P) does NOT perform a correct simulation of its input.
>>>> That the execution trace of the simulated input to H(P,P) exactly
>>>> matches the behavior specified by its x86 source-code provides the
>>>> ultimate measure of a correct simulation thus overriding and superseding
>>>> any and all other measures.
>>>>
>>>> _P()
>>>> [000009d6](01) 55 push ebp
>>>> [000009d7](02) 8bec mov ebp,esp
>>>> [000009d9](03) 8b4508 mov eax,[ebp+08]
>>>> [000009dc](01) 50 push eax // push P
>>>> [000009dd](03) 8b4d08 mov ecx,[ebp+08]
>>>> [000009e0](01) 51 push ecx // push P
>>>> [000009e1](05) e840feffff call 00000826 // call H
>>>> [000009e6](03) 83c408 add esp,+08
>>>> [000009e9](02) 85c0 test eax,eax
>>>> [000009eb](02) 7402 jz 000009ef
>>>> [000009ed](02) ebfe jmp 000009ed
>>>> [000009ef](01) 5d pop ebp
>>>> [000009f0](01) c3 ret // Final state
>>>> Size in bytes:(0027) [000009f0]
>>>>
>>>> Begin Local Halt Decider Simulation
>>>> machine stack stack machine assembly
>>>> address address data code language
>>>> ======== ======== ======== ========= =============
>>>> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
>>>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
>>>> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
>>>> ...[000009dc][00211364][000009d6] 50 push eax // Push P
>>>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
>>>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
>>>> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
>>>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
>>>> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
>>>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
>>>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
>>>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>> --
>>>> Copyright 2022 Pete Olcott "Talent hits a target no one else can hit;
>>>> Genius hits a target no one else can see." Arthur Schopenhauer
>>>
>>> All this trace shows is that H aborted its input.
>> This trace of the correctly simulated input to H(P,P) conclusively
>> proves that when P calls the same function with the same parameters from
>> the same address that H has its reject (non-halting) criteria.
>
> This trace is however missing the steps in the embedded call to H. Those steps contain a number of conditions that could abort, and in fact *will* abort if allowed to continue, but H is unable to account for that.

This is moot. The halt decider knows that it never aborts an input until
after it has proof that its input is non-halting. This means that it can
safely ignores that thousands of pages of execution trace.

The above trace proves that the correctly simulated into to H(P,P) calls
H(P,P) to a recursion depth of two when H determine this would never stop.

>
> The traces of H(P,P) and H1(P,P) are identical up until the point that H aborts. After that point, H1 continues to simulate the same input and sees that the embedded copy of H aborts and causes P to halt.
>
> This provided CONCLUSIVE proof that H aborted its simulation too soon and that the input is in fact halting and that H(P,P) == false is wrong.
>
> Of course, there is a much simpler criteria to see whether H(P,P) gives the correct answer, and that is the definition of the halting function:
>
> H(M,w) == true if and only if M(w) halts, and
> H(M,w) == false if and only if M(w) does not halt
>
> P(P) halts, therefore the correct mapping is true, therefore H(P,P) == false in wrong.

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