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.

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.