On Sun, 19 Jun 2022 18:31:27 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/19/2022 6:27 PM, Mr Flibble wrote:
> > On Sun, 19 Jun 2022 18:25:33 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/19/2022 5:58 PM, Mr Flibble wrote:
> >>> On Sun, 19 Jun 2022 18:53:36 -0400
> >>> Richard Damon <Richard@Damon-Family.org> wrote:
> >>>
> >>>> On 6/19/22 6:22 PM, Mr Flibble wrote:
> >>>>> On Sun, 19 Jun 2022 17:16:03 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/19/2022 4:46 PM, Mr Flibble wrote:
> >>>>>>> On Sun, 19 Jun 2022 16:23:17 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 6/19/2022 4:20 PM, Mr Flibble wrote:
> >>>>>>>>> On Sun, 19 Jun 2022 16:17:20 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 6/19/2022 4:00 PM, Richard Damon wrote:
> >>>>>>>>>>> On 6/19/22 4:43 PM, olcott wrote:
> >>>>>>>>>>>> On 6/19/2022 3:31 PM, Mr Flibble wrote:
> >>>>>>>>>>>>> On Sun, 19 Jun 2022 15:16:05 -0500
> >>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> On 6/19/2022 3:08 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>> On Sun, 19 Jun 2022 15:05:11 -0500
> >>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>> On 6/19/2022 2:59 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 14:17:42 -0500
> >>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>> On 6/19/2022 1:43 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>> On 6/19/22 2:30 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 6/19/2022 1:20 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>> On 6/19/22 2:08 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 12:40 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 12:16:05 -0500
> >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 12:01 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 11:23:24 -0500
> >>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 11:01 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500
> >>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation that halts … the Turing
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine will halt whenever it enters a
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state. (Linz:1990:234)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A halt decider must compute the mapping
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from its inputs to an accept or reject
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state on the basis of the actual
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of these actual inputs.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When a simulating halt decider rejects
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> all inputs as non-halting whenever it
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly detects [in a finite number
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of steps] that its correct and complete
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input would never
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach [a] final state of this input
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then all [these] inputs (including
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pathological inputs) are decided
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Px(u32 x)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>           H(x, x);
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>           return;
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>           Output("Input_Halts = ",
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000013e8][00102357][00000000] 83c408
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000013eb][00102353][00000000] 50
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000013ec][0010234f][00000427]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000013f1][0010234f][00000427]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts > >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0 ...[000013f6][00102357][00000000]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> 83c408 add esp,+08
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f9][00102357][00000000] 33c0
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> xor eax,eax
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000013fb][0010235b][00100000] 5d
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> ret Number of Instructions
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Executed(16120)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> It gets the answer wrong, i.e. input has
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> not been decided correctly. QED.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> _P()
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010fa](01)  55              push ebp
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> [000010fb](02)  8bec            mov
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000010fd](03)  8b4508
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08] [00001100](01)  50
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax       // push P [00001101](03)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> 8b4d08          mov ecx,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001104](01)  51              push ecx
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> // push P [00001105](05)  e800feffff call
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> 00000f0a  // call H [0000110a](03)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> 83c408 add esp,+08 [0000110d](02)  85c0
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> test eax,eax [0000110f](02)  7402
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>     jz 00001113 [00001111](02)  ebfe
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> jmp 00001111 [00001113](01)  5d
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>   pop ebp [00001114](01)  c3
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> ret Size in bytes:(0027) [00001114]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Begin Simulation   Execution Trace Stored
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> at:211ee2
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000010da][00211ece][00211ed2] 55
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov eax,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000010e0][00211eca][000010da] 50
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> push eax // push P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000010e1][00211eca][000010da] 8b4d08
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000010e4][00211ec6][000010da] 51
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> push ecx // push P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000010e5][00211ec2][000010ea]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> e820feffff call 00000f0a // call H
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinitely Recursive Simulation Detected
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulation Stopped
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> *All technically competent software
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> engineers* will see that when H bases its
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> halt status decision on whether or not
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> its complete and correct x86 emulation
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input would ever reach the "ret"
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction of this input that H is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> correct to reject this input.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> void Px(u32 x)
> >>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>          H(x, x);
> >>>>>>>>>>>>>>>>>>>>>>>>>>>          return;
> >>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>          Output("Input_Halts = ",
> >>>>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000013e8][00102357][00000000] 83c408
> >>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
> >>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000013eb][00102353][00000000] 50 push
> >>>>>>>>>>>>>>>>>>>>>>>>>>> eax ...[000013ec][0010234f][00000427]
> >>>>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
> >>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000013f1][0010234f][00000427]
> >>>>>>>>>>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0
> >>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408
> >>>>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
> >>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f9][00102357][00000000] 33c0 xor
> >>>>>>>>>>>>>>>>>>>>>>>>>>> eax,eax ...[000013fb][0010235b][00100000]
> >>>>>>>>>>>>>>>>>>>>>>>>>>> 5d pop ebp
> >>>>>>>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret
> >>>>>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> It gets the answer wrong, i.e. input has
> >>>>>>>>>>>>>>>>>>>>>>>>>>> not been decided correctly. QED.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> *All technically competent software
> >>>>>>>>>>>>>>>>>>>>>>>>>> engineers*
> >>>>>>>>>>>>>>>>>>>>>>>>> void Px(u32 x)
> >>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>         H(x, x);
> >>>>>>>>>>>>>>>>>>>>>>>>>         return;
> >>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>         Output("Input_Halts = ",
> >>>>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> ...[000013e8][00102357][00000000] 83c408
> >>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
> >>>>>>>>>>>>>>>>>>>>>>>>> ...[000013eb][00102353][00000000] 50 push
> >>>>>>>>>>>>>>>>>>>>>>>>> eax ...[000013ec][0010234f][00000427]
> >>>>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
> >>>>>>>>>>>>>>>>>>>>>>>>> ---[000013f1][0010234f][00000427]
> >>>>>>>>>>>>>>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0
> >>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408
> >>>>>>>>>>>>>>>>>>>>>>>>> add esp,+08
> >>>>>>>>>>>>>>>>>>>>>>>>> ...[000013f9][00102357][00000000] 33c0 xor
> >>>>>>>>>>>>>>>>>>>>>>>>> eax,eax ...[000013fb][0010235b][00100000]
> >>>>>>>>>>>>>>>>>>>>>>>>> 5d pop ebp
> >>>>>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret
> >>>>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120)
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> It gets the answer wrong, i.e. input has not
> >>>>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> Because it is an easily verified fact that
> >>>>>>>>>>>>>>>>>>>>>>>> the correct and complete x86 emulation of
> >>>>>>>>>>>>>>>>>>>>>>>> the input to H(P,P) by H would never reach
> >>>>>>>>>>>>>>>>>>>>>>>> the "ret" instruction of P and this is the
> >>>>>>>>>>>>>>>>>>>>>>>> criterion measure for H to reject its input
> >>>>>>>>>>>>>>>>>>>>>>>> how do you figure that H gets the wrong
> >>>>>>>>>>>>>>>>>>>>>>>> answer?
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> What I am saying is a logical tautology the
> >>>>>>>>>>>>>>>>>>>>>>>> same as when we know that X is a black cat
> >>>>>>>>>>>>>>>>>>>>>>>> then we know that X is a cat.
> >>>>>>>>>>>>>>>>>>>>>>> We are talking about Px, not P. We are talking
> >>>>>>>>>>>>>>>>>>>>>>> about your H not analysing what its input
> >>>>>>>>>>>>>>>>>>>>>>> actually does and instead assuming that an
> >>>>>>>>>>>>>>>>>>>>>>> input that calls H is always pathological.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> void Px(u32 x)
> >>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>        H(x, x);
> >>>>>>>>>>>>>>>>>>>>>>>        return;
> >>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>        Output("Input_Halts = ",
> >>>>>>>>>>>>>>>>>>>>>>> H((u32)Px, (u32)Px)); }
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> ...[000013e8][00102357][00000000] 83c408
> >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013eb][00102353][00000000]
> >>>>>>>>>>>>>>>>>>>>>>> 50 push eax ...[000013ec][0010234f][00000427]
> >>>>>>>>>>>>>>>>>>>>>>> 6827040000 push 00000427
> >>>>>>>>>>>>>>>>>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff
> >>>>>>>>>>>>>>>>>>>>>>> call 00000476 Input_Halts = 0
> >>>>>>>>>>>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408
> >>>>>>>>>>>>>>>>>>>>>>> add esp,+08 ...[000013f9][00102357][00000000]
> >>>>>>>>>>>>>>>>>>>>>>> 33c0 xor eax,eax
> >>>>>>>>>>>>>>>>>>>>>>> ...[000013fb][0010235b][00100000] 5d pop ebp
> >>>>>>>>>>>>>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3 ret
> >>>>>>>>>>>>>>>>>>>>>>> Number of Instructions Executed(16120)
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> It gets the answer wrong, i.e. input has not
> >>>>>>>>>>>>>>>>>>>>>>> been decided correctly. QED.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> DO YOU AGREE WITH THIS?
> >>>>>>>>>>>>>>>>>>>>>> H(Px,Px) does correctly determine that the
> >>>>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation of its input
> >>>>>>>>>>>>>>>>>>>>>> would never reach the "ret" instruction of Px.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> That is only true if H never returns ANY answer
> >>>>>>>>>>>>>>>>>>>>> (and thus fails to be a decider).
> >>>>>>>>>>>>>>>>>>>> Competent software engineers will understand that
> >>>>>>>>>>>>>>>>>>>> when the behavior of Px matches this pattern that
> >>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of the input
> >>>>>>>>>>>>>>>>>>>> to H(Px,Px) by H would never reach the "ret"
> >>>>>>>>>>>>>>>>>>>> instruction of Px:
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> H knows its own machine address and on this
> >>>>>>>>>>>>>>>>>>>> basis: (a) H recognizes that Px is calling H
> >>>>>>>>>>>>>>>>>>>> with the same arguments that H was called with.
> >>>>>>>>>>>>>>>>>>>> (b) There are no instructions in Px that could
> >>>>>>>>>>>>>>>>>>>> possibly escape this infinitely recursive
> >>>>>>>>>>>>>>>>>>>> emulation. (c) H aborts its emulation of Px
> >>>>>>>>>>>>>>>>>>>> before Px its call to H is invoked.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> Only if H never aborts. If H does abort, then
> >>>>>>>>>>>>>>>>>>> Px(Px), whose behavior exactly matches the CORRECT
> >>>>>>>>>>>>>>>>>>> emulation of the input to H(Px,Px) BY DEFINITION
> >>>>>>>>>>>>>>>>>>> shows this.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> The question is: Would (future tense) the complete
> >>>>>>>>>>>>>>>>>> and correct x86 emulation of the input to H(Px,Px)
> >>>>>>>>>>>>>>>>>> by H ever reach the "ret" instruction of Px.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> You always change this question to a different
> >>>>>>>>>>>>>>>>>> question:
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Does (present tense) the complete and correct x86
> >>>>>>>>>>>>>>>>>> emulation of the input to H(Px,Px) by H ever reach
> >>>>>>>>>>>>>>>>>> the "ret" instruction of Px.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> The complete and correct x86 emulation of the input
> >>>>>>>>>>>>>>>>> to H(Px, Px) should be to allow Px to halt, which
> >>>>>>>>>>>>>>>>> is what Px is defined to do:
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> You are doing the same thing Richard is doing,
> >>>>>>>>>>>>>>>> getting at least one word of what I am saying
> >>>>>>>>>>>>>>>> incorrectly and then rebutting the incorrect
> >>>>>>>>>>>>>>>> paraphrase. This is the strawman error.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> The complete and correct x86 emulation of the input
> >>>>>>>>>>>>>>>> to H(Px, Px) BY H
> >>>>>>>>>>>>>>>> BY H
> >>>>>>>>>>>>>>>> BY H
> >>>>>>>>>>>>>>>> BY H
> >>>>>>>>>>>>>>>> BY H
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> cannot possibly contradict the easily verified fact
> >>>>>>>>>>>>>>>> that Px would never reach its "ret" instruction. This
> >>>>>>>>>>>>>>>> seems to be beyond your ordinary software engineering
> >>>>>>>>>>>>>>>> technical competence.
> >>>>>>>>>>>>>>> Px is defined to always halt; your H gets the answer
> >>>>>>>>>>>>>>> wrong saying Px doesn't halt. QED.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Every technically competent software engineer can
> >>>>>>>>>>>>>> easily confirm that the correct and complete x86
> >>>>>>>>>>>>>> emulation of the input to H(Px,Px) by H would never
> >>>>>>>>>>>>>> reach the "ret" instruction of Px.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> That you can not understand this proves that you are
> >>>>>>>>>>>>>> not a sufficiently technically competent software
> >>>>>>>>>>>>>> engineer on this point. Very good COBOL programmers
> >>>>>>>>>>>>>> might never be able to understand this.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> To anyone that writes or maintains operating systems
> >>>>>>>>>>>>>> what I am claiming would be as easy to verify as first
> >>>>>>>>>>>>>> grade arithmetic.
> >>>>>>>>>>>>> void Px(u32 x)
> >>>>>>>>>>>>> {
> >>>>>>>>>>>>>     H(x, x);
> >>>>>>>>>>>>>     return;
> >>>>>>>>>>>>> }
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> int main()
> >>>>>>>>>>>>> {
> >>>>>>>>>>>>>     Output("Input_Halts = ", H((u32)Px, (u32)Px));
> >>>>>>>>>>>>> }
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> ...[000013e8][00102357][00000000] 83c408          add
> >>>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
> >>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] 6827040000
> >>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427]
> >>>>>>>>>>>>> e880f0ffff call 00000476 Input_Halts = 0
> >>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408          add
> >>>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
> >>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d
> >>>>>>>>>>>>>   pop ebp ...[000013fc][0010235f][00000004] c3
> >>>>>>>>>>>>> ret Number of Instructions Executed(16120)
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> It gets the answer wrong, i.e. input has not been
> >>>>>>>>>>>>> decided correctly. QED.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> Get an operating system programmer to explain to you that
> >>>>>>>>>>>> the correct and complete x86 emulation of the input to
> >>>>>>>>>>>> H(Px,Px) by H would never reach the "ret" instruction of
> >>>>>>>>>>>> Px. *This is totally over your head*
> >>>>>>>>>>>>
> >>>>>>>>>>>> It is like I am saying that we know that black carts are
> >>>>>>>>>>>> cats and you disagree saying the a black cat might be
> >>>>>>>>>>>> some kind of dog.
> >>>>>>>>>>>>
> >>>>>>>>>>>> My whole system is now wrapped in 131K zip file as a
> >>>>>>>>>>>> Visual Studio project on a downloadable link.
> >>>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> No, maybe you need an actual programmer to look at your
> >>>>>>>>>>> logic.
> >>>>>>>>>>>
> >>>>>>>>>>> First, by definition correct emulation of a program will
> >>>>>>>>>>> match the behavior of the program.
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> When you disagree with this precisely stated verified fact
> >>>>>>>>>> you are either a liar or incompetent:
> >>>>>>>>>>
> >>>>>>>>>> the correct and complete x86 emulation of the input to
> >>>>>>>>>> H(Px,Px) by H would never reach the "ret" instruction
> >>>>>>>>>>
> >>>>>>>>>> When you disagree the the above precisely stated verified
> >>>>>>>>>> fact by changing its words and showing that the changed
> >>>>>>>>>> words are not true then between liar and incompetent you
> >>>>>>>>>> prove to be a liar.
> >>>>>>>>>
> >>>>>>>>> void Px(u32 x)
> >>>>>>>>> {
> >>>>>>>>> H(x, x);
> >>>>>>>>> return;
> >>>>>>>>> }
> >>>>>>>>>
> >>>>>>>>> int main()
> >>>>>>>>> {
> >>>>>>>>> Output("Input_Halts = ", H((u32)Px, (u32)Px));
> >>>>>>>>> }
> >>>>>>>>>
> >>>>>>>>> ...[000013e8][00102357][00000000] 83c408 add
> >>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
> >>>>>>>>> push eax ...[000013ec][0010234f][00000427] 6827040000
> >>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff
> >>>>>>>>> call 00000476 Input_Halts = 0
> >>>>>>>>> ...[000013f6][00102357][00000000] 83c408 add
> >>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
> >>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d
> >>>>>>>>> pop ebp ...[000013fc][0010235f][00000004] c3
> >>>>>>>>> ret Number of Instructions Executed(16120)
> >>>>>>>>>
> >>>>>>>>> It gets the answer wrong, i.e. input has not been decided
> >>>>>>>>> correctly. QED.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>
> >>>>>>>>
> >>>>>>>> DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
> >>>>>>>> the correct and complete x86 emulation of the input to
> >>>>>>>> H(Px,Px) by H would never reach the "ret" instruction
> >>>>>>>
> >>>>>>> What I am saying is the following, no more, no less:
> >>>>>>>
> >>>>>>> void Px(u32 x)
> >>>>>>> {
> >>>>>>> H(x, x);
> >>>>>>> return;
> >>>>>>> }
> >>>>>>>
> >>>>>>> int main()
> >>>>>>> {
> >>>>>>> Output("Input_Halts = ", H((u32)Px, (u32)Px));
> >>>>>>> }
> >>>>>>>
> >>>>>>> ...[000013e8][00102357][00000000] 83c408 add esp,+08
> >>>>>>> ...[000013eb][00102353][00000000] 50 push eax
> >>>>>>> ...[000013ec][0010234f][00000427] 6827040000 push
> >>>>>>> 00000427 ---[000013f1][0010234f][00000427] e880f0ffff
> >>>>>>> call 00000476 Input_Halts = 0
> >>>>>>> ...[000013f6][00102357][00000000] 83c408 add esp,+08
> >>>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
> >>>>>>> ...[000013fb][0010235b][00100000] 5d pop ebp
> >>>>>>> ...[000013fc][0010235f][00000004] c3 ret
> >>>>>>> Number of Instructions Executed(16120)
> >>>>>>>
> >>>>>>> It gets the answer wrong, i.e. input has not been decided
> >>>>>>> correctly. QED.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>>
> >>>>>>
> >>>>>> You are not committing to a criterion measure of correctness
> >>>>>> thus your claim is vague.
> >>>>>
> >>>>> Vague? My "claim" is crystal clear: Px should ALWAYS HALT and
> >>>>> your H decides that it is non-halting.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> Flibble, Px doesn't "Always" Halt. If H(Px,Px) doesn't return
> >>>> because it gets stuck in an infinite loop, then Px(Px) doesn't
> >>>> Halt.
> >>>>
> >>>> Now, this H fails to be a decider, so can't be a counter example
> >>>> for a Halt Decider.
> >>>
> >>> If H is a valid halt decider (and by that I mean returns an answer
> >>> in finite time) then Px *will* always halt: it doesn't because
> >>> Olcott's H is not a valid halt decider.
> >>>
> >>> /Flibble
> >>>
> >>
> >> Now that H has been very recently adapted to be a pure function of
> >> its inputs whenever it is invoked it always returns on finite time.
> >> H aborts its simulation of Px before Px invokes H.
> >>
> >> H knows its own machine address and on this basis:
> >> (a) H recognizes that Px is calling H with the same arguments that
> >> H was called with.
> >> (b) There are no instructions in Px that could possibly escape this
> >> infinitely recursive emulation.
> >> (c) H aborts its emulation of Px before its call to H is invoked.
> >
> > void Px(u32 x)
> > {
> > H(x, x);
> > return;
> > }
> >
> > int main()
> > {
> > Output("Input_Halts = ", H((u32)Px, (u32)Px));
> > }
> >
> > ...[000013e8][00102357][00000000] 83c408 add esp,+08
> > ...[000013eb][00102353][00000000] 50 push eax
> > ...[000013ec][0010234f][00000427] 6827040000 push 00000427
> > ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
> > Input_Halts = 0
> > ...[000013f6][00102357][00000000] 83c408 add esp,+08
> > ...[000013f9][00102357][00000000] 33c0 xor eax,eax
> > ...[000013fb][0010235b][00100000] 5d pop ebp
> > ...[000013fc][0010235f][00000004] c3 ret
> > Number of Instructions Executed(16120)
> >
> > It gets the answer wrong, i.e. input has not been decided correctly.
> > QED.
> >
> > /Flibble
> >
>
> So you are a mere bot now.
Until you offer something new I cannot be bothered to.

/Flibble