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.

Olcotts problem is his H falsely presumes that the H that Px calls is
that H not the actual H doing the decision, so it doesn't actually make
a correct evaluation of its input.