On 5/6/22 2:35 AM, olcott wrote:
> 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.

Except that isn't a correct trace, as has been pointed out before.

After the call to H, your claimed trace is NOT what atually happpens
unless H actuall CALL its input (and ths has given up control to allow
it to abort), and in that case, you need the trace of the statements in
H that do that.

If H actually does "simulated" (or "Debug Step") the code, then the
trace needs to show that action happening.

That you think this is moot is irrelevent, if you decide that cats bark
because your dog does, you are making an incorrect deduction, it doesn't
matter that you "THINK" you are doing it right.

And your claim that H made a correct decision is wrong because it uses
invalid logic. It doesn't matter that the copy of H that H is simulating
won't make the decision to abort until after H stops simulating, the
fact that it WILL decide to abort is proof that H decided unsoundly,
because the rule it is trying to use is base on that copy NEVER aborting.

Your ignoring the actual facts of the case just prove that you are a
total failure at doing logic, and thus your opinion on what is or is not
relevant worthless.

If you can't provide and live by the definitions of the things your are
talking about, you are just shown to be the liar that will be thrown in
the lake of fire.

Don't forget to bring your marshmallows.

>
>>
>> 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.
>
>