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

> On 6/19/2022 5: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 knows that he is so woefully incompetent that he refuses to
> answer whether or not the following is true or false:
>
> the correct and complete x86 emulation of the input to H(Px,Px) by
> H would never reach the "ret" instruction
>
> If one has no idea whether or not a statement is true or false and
> they want to hide the fact that they have no idea then when
> repeatedly pressed to provide an answer the best that they can
> possibly do is continue to dodge the question.
>
> it is no longer worth my time to continue to talk to you of Richard.
I told you before: block away. Blocking me will not stop me pointing
the following out every time you start a "new" topic repeating the same
old shit:

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