novaBBS - comp.ai.philosophy - Re: Halting Problem proof refutation is a tautology thus irrefutable [ liar or incompetent ]

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.

Click here to read the complete article

On 6/19/2022 4:56 PM, Richard Damon wrote:
> On 6/19/22 5:34 PM, olcott wrote:
>> On 6/19/2022 4:23 PM, Richard Damon wrote:
>>>
>>> On 6/19/22 4:55 PM, olcott wrote:
>>>> On 6/19/2022 3:50 PM, Richard Damon wrote:
>>>>> On 6/19/22 4:34 PM, olcott wrote:
>>>>>> On 6/19/2022 3:19 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 6/19/22 3:17 PM, olcott 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.
>>>>>>>
>>>>>>> What "Future Tense".
>>>>>> A halt decider must always correctly determine whether or not its
>>>>>> input WOULD halt. If halt deciders reported what the behavior of
>>>>>> its input
>>>>>> DOES then like you said it would never report on non halting inputs.
>>>>>>
>>>>>> All non-simulating halt deciders can only report on what their input
>>>>>> WOULD do and not what their input DOES because non-simulating halt
>>>>>> deciders are static rather than dynamic analyzers.
>>>>>>
>>>>>
>>>>> Would only in the sense of condition of testing, not time.
>>>> Halt deciders must always predict what their non-halting inputs
>>>> would do in the future if they were executed.
>>>
>>> Why?
>>>
>>> There is no actual requirement to execute the machine, only know what
>>> would happen if at some point we did do that execution either in the
>>> past or the future.
>>>
>>>>
>>>> They can never report on the non-halting behavior of what their
>>>> inputs did do in the past.
>>>
>>> Why not?
>>
>> If they are simulating halt deciders they can
>> never report on
>> never report on
>> never report on
>> never report on
>> never report on
>>
>> the non-halting behavior
>> the non-halting behavior
>> the non-halting behavior
>> the non-halting behavior
>> the non-halting behavior
>>
>> of what their inputs did do in the past
>> of what their inputs did do in the past
>> of what their inputs did do in the past
>> of what their inputs did do in the past
>> of what their inputs did do in the past
>>
>> Because as you have said 1000 times they would be
>> stuck simulating this non-halting input forever.
>>
>> If they are not simulating halt deciders they can
>> never report on
>> never report on
>> never report on
>> never report on
>> never report on
>>
>> the non-halting behavior
>> the non-halting behavior
>> the non-halting behavior
>> the non-halting behavior
>> the non-halting behavior
>>
>> Because they are not even examining behavior they are
>> only static analyzers that do not look at dynamic behavior.
>>
>> Therefore halt deciders can never report on the non-halting behavior
>> of what their inputs did do in the past.
>>
>> Therefore halt deciders can never report on the non-halting behavior
>> of what their inputs did do in the past.
>>
>> Therefore halt deciders can never report on the non-halting behavior
>> of what their inputs did do in the past.
>>
>> Therefore halt deciders can never report on the non-halting behavior
>> of what their inputs did do in the past.
>>
>> Therefore halt deciders can never report on the non-halting behavior
>> of what their inputs did do in the past.
>>
>>
>
> Regressing back to a two year old again I see.

Click here to read the complete article

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
>

Click here to read the complete article

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.

Click here to read the complete article

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
>

Click here to read the complete article

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.

Click here to read the complete article

On 6/19/22 6:25 PM, olcott wrote:
> On 6/19/2022 4:56 PM, Richard Damon wrote:
>> On 6/19/22 5:34 PM, olcott wrote:
>>> On 6/19/2022 4:23 PM, Richard Damon wrote:
>>>>
>>>> On 6/19/22 4:55 PM, olcott wrote:
>>>>> On 6/19/2022 3:50 PM, Richard Damon wrote:
>>>>>> On 6/19/22 4:34 PM, olcott wrote:
>>>>>>> On 6/19/2022 3:19 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 6/19/22 3:17 PM, olcott 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.
>>>>>>>>
>>>>>>>> What "Future Tense".
>>>>>>> A halt decider must always correctly determine whether or not its
>>>>>>> input WOULD halt. If halt deciders reported what the behavior of
>>>>>>> its input
>>>>>>> DOES then like you said it would never report on non halting inputs.
>>>>>>>
>>>>>>> All non-simulating halt deciders can only report on what their input
>>>>>>> WOULD do and not what their input DOES because non-simulating halt
>>>>>>> deciders are static rather than dynamic analyzers.
>>>>>>>
>>>>>>
>>>>>> Would only in the sense of condition of testing, not time.
>>>>> Halt deciders must always predict what their non-halting inputs
>>>>> would do in the future if they were executed.
>>>>
>>>> Why?
>>>>
>>>> There is no actual requirement to execute the machine, only know
>>>> what would happen if at some point we did do that execution either
>>>> in the past or the future.
>>>>
>>>>>
>>>>> They can never report on the non-halting behavior of what their
>>>>> inputs did do in the past.
>>>>
>>>> Why not?
>>>
>>> If they are simulating halt deciders they can
>>> never report on
>>> never report on
>>> never report on
>>> never report on
>>> never report on
>>>
>>> the non-halting behavior
>>> the non-halting behavior
>>> the non-halting behavior
>>> the non-halting behavior
>>> the non-halting behavior
>>>
>>> of what their inputs did do in the past
>>> of what their inputs did do in the past
>>> of what their inputs did do in the past
>>> of what their inputs did do in the past
>>> of what their inputs did do in the past
>>>
>>> Because as you have said 1000 times they would be
>>> stuck simulating this non-halting input forever.
>>>
>>> If they are not simulating halt deciders they can
>>> never report on
>>> never report on
>>> never report on
>>> never report on
>>> never report on
>>>
>>> the non-halting behavior
>>> the non-halting behavior
>>> the non-halting behavior
>>> the non-halting behavior
>>> the non-halting behavior
>>>
>>> Because they are not even examining behavior they are
>>> only static analyzers that do not look at dynamic behavior.
>>>
>>> Therefore halt deciders can never report on the non-halting behavior
>>> of what their inputs did do in the past.
>>>
>>> Therefore halt deciders can never report on the non-halting behavior
>>> of what their inputs did do in the past.
>>>
>>> Therefore halt deciders can never report on the non-halting behavior
>>> of what their inputs did do in the past.
>>>
>>> Therefore halt deciders can never report on the non-halting behavior
>>> of what their inputs did do in the past.
>>>
>>> Therefore halt deciders can never report on the non-halting behavior
>>> of what their inputs did do in the past.
>>>
>>>
>>
>> Regressing back to a two year old again I see.
>
> That I have to tell you the same thing hundreds and hundreds of times
> before you notice that I said it once is best handled by plonking you.

Click here to read the complete article

On 6/19/22 6: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
>

Click here to read the complete article

On 6/19/22 5:17 PM, olcott wrote:
>
> When you disagree with this precisely stated verified fact you are
> either a liar or incompetent:

And when you state facts have been "verified" when they haven't, your a
liar.

Maybe you are too dumb to realize that your "proofs" have been rebutted,
but using stupidity as an excuse only goes so far.

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
>

Click here to read the complete article

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.

Click here to read the complete article

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
>

Click here to read the complete article

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

Click here to read the complete article

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.

Click here to read the complete article

On 6/19/2022 6:32 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.
>
> To be a valid halt decider H must always return a value to its invoker,
> in this case Px; it doesn't so it isn't a valid halt decider.
>
> /Flibble
>

Click here to read the complete article

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

> On 6/19/2022 6:32 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.
> >
> > To be a valid halt decider H must always return a value to its
> > invoker, in this case Px; it doesn't so it isn't a valid halt
> > decider.
> >
> > /Flibble
> >
>
> When a function is called in infinite recursion it merely never stops.
>
> When a halt decider is called in infinite recursion it essentially
> says https://www.youtube.com/watch?v=Z6EsNyIRG-g

Click here to read the complete article

On 6/19/22 7:25 PM, olcott 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.
>

Click here to read the complete article

On 6/19/22 7:44 PM, olcott wrote:
>>
>
> When a function is called in infinite recursion it merely never stops.
>
> When a halt decider is called in infinite recursion it essentially says
> https://www.youtube.com/watch?v=Z6EsNyIRG-g

Whixh means that the function used the halt decider doesn't get into the
infinite loop either, BECAUSE the Halt decider stopped the loop.

Your problem is your H thinks it will but then it doesn't so it just was
incorrect about the behavior.

And, there is no special case in the definitions that allow it to get a
pass for this case.

FAIL.

On 2022-06-19 16:18, olcott wrote:
> On 6/19/2022 5:02 PM, André G. Isaak wrote:
>> On 2022-06-19 14:43, olcott wrote:
>>
>>> My whole system is now wrapped in 131K zip file as a Visual Studio
>>> project on a downloadable link.
>>
>> I see no link anywhere.
>>
>> André
>>
>
> Are you sure maybe you didn't look hard enough?
> Maybe there is an invisible link between "131K" and "zip"

If you posted it somewhere, wouldn't it be easier to simply repost the
link rather than make snide comments?

Or if you don't intend to post the link, then say so.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

On 6/19/22 6:18 PM, olcott wrote:
> On 6/19/2022 5:02 PM, André G. Isaak wrote:
>> On 2022-06-19 14:43, olcott wrote:
>>
>>> My whole system is now wrapped in 131K zip file as a Visual Studio
>>> project on a downloadable link.
>>
>> I see no link anywhere.
>>
>> André
>>
>
> Are you sure maybe you didn't look hard enough?
> Maybe there is an invisible link between "131K" and "zip"
>

Except that there isn't one. Note Content-type Text/Plain doesn't have a
way to "Hide" links.

My guess is this is just your normal less-than-truthful sort of comment.

On 6/19/2022 9:27 PM, André G. Isaak wrote:
> On 2022-06-19 16:18, olcott wrote:
>> On 6/19/2022 5:02 PM, André G. Isaak wrote:
>>> On 2022-06-19 14:43, olcott wrote:
>>>
>>>> My whole system is now wrapped in 131K zip file as a Visual Studio
>>>> project on a downloadable link.
>>>
>>> I see no link anywhere.
>>>
>>> André
>>>
>>
>> Are you sure maybe you didn't look hard enough?
>> Maybe there is an invisible link between "131K" and "zip"
>
> If you posted it somewhere, wouldn't it be easier to simply repost the
> link rather than make snide comments?
>
> Or if you don't intend to post the link, then say so.
>
> André
>

I do not intend to post the link very soon.
Because reviewers here have been so consistently disparaging of my work
they will be last in line to be able to have access to this code.

When I boiled my claims down to two easily verified facts of software
engineering and everyone consistently still disagreed then I knew that
none of my reviewers were both sufficiently technically competent and
honest.

It is a very 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. Only one reviewer out of 100 reviewers in a dozen
different forums over the period of a year would acknowledge that.

The x86 emulator code is immaculate because I was very cautious in my
slight changes to keep it very clean. H is the one halt decider that has
all of its code quite clean and finally a pure function of its inputs.
The x86utm operating system code is very reliable yet quite messy.

At this point I have provided enough evidence that reasonable people
would conclude that all of my claims of having actual code have been
sufficiently proven. I decided that posting this code as a Google Drive
downloadable link to a complete Visual Studio project is the way to go.

The solution is defined so that immediately after the build the halt
decider can be directly run from inside Visual Studio. The halt decider
file itself can be edited to run different halt deciders on a small
library of sample inputs. Right out of the box H(P,P) is executed.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On 2022-06-19 21:14, olcott wrote:
> On 6/19/2022 9:27 PM, André G. Isaak wrote:
>> On 2022-06-19 16:18, olcott wrote:
>>> On 6/19/2022 5:02 PM, André G. Isaak wrote:
>>>> On 2022-06-19 14:43, olcott wrote:
>>>>
>>>>> My whole system is now wrapped in 131K zip file as a Visual Studio
>>>>> project on a downloadable link.
>>>>
>>>> I see no link anywhere.
>>>>
>>>> André
>>>>
>>>
>>> Are you sure maybe you didn't look hard enough?
>>> Maybe there is an invisible link between "131K" and "zip"
>>
>> If you posted it somewhere, wouldn't it be easier to simply repost the
>> link rather than make snide comments?
>>
>> Or if you don't intend to post the link, then say so.
>>
>> André
>>
>
> I do not intend to post the link very soon.

So then why bother mentioning it at all?

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

On 6/19/2022 10:32 PM, André G. Isaak wrote:
> On 2022-06-19 21:14, olcott wrote:
>> On 6/19/2022 9:27 PM, André G. Isaak wrote:
>>> On 2022-06-19 16:18, olcott wrote:
>>>> On 6/19/2022 5:02 PM, André G. Isaak wrote:
>>>>> On 2022-06-19 14:43, olcott wrote:
>>>>>
>>>>>> My whole system is now wrapped in 131K zip file as a Visual Studio
>>>>>> project on a downloadable link.
>>>>>
>>>>> I see no link anywhere.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> Are you sure maybe you didn't look hard enough?
>>>> Maybe there is an invisible link between "131K" and "zip"
>>>
>>> If you posted it somewhere, wouldn't it be easier to simply repost
>>> the link rather than make snide comments?
>>>
>>> Or if you don't intend to post the link, then say so.
>>>
>>> André
>>>
>>
>> I do not intend to post the link very soon.
>
> So then why bother mentioning it at all?
>
> André
>
>

That I have all of the code fully operational in a single 131K zipped
Visual studio project is a key milestone.

On 3/14/2017 9:05 AM, peteolcott wrote: in comp.theory
[Solution to one instance of the Halting Problem]

Is when I first showed that a simulating halt decider could correctly
determine that the conventional input to the halting problem proofs
could be correctly decided as non-halting on the basis that they specify
infinitely nested simulation to every simulating halt decider.

It has been an average of at least full time work on this project ever
since.

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On 6/19/22 11:14 PM, olcott wrote:
> On 6/19/2022 9:27 PM, André G. Isaak wrote:
>> On 2022-06-19 16:18, olcott wrote:
>>> On 6/19/2022 5:02 PM, André G. Isaak wrote:
>>>> On 2022-06-19 14:43, olcott wrote:
>>>>
>>>>> My whole system is now wrapped in 131K zip file as a Visual Studio
>>>>> project on a downloadable link.
>>>>
>>>> I see no link anywhere.
>>>>
>>>> André
>>>>
>>>
>>> Are you sure maybe you didn't look hard enough?
>>> Maybe there is an invisible link between "131K" and "zip"
>>
>> If you posted it somewhere, wouldn't it be easier to simply repost the
>> link rather than make snide comments?
>>
>> Or if you don't intend to post the link, then say so.
>>
>> André
>>
>
> I do not intend to post the link very soon.
> Because reviewers here have been so consistently disparaging of my work
> they will be last in line to be able to have access to this code.
>
> When I boiled my claims down to two easily verified facts of software
> engineering and everyone consistently still disagreed then I knew that
> none of my reviewers were both sufficiently technically competent and
> honest.

No, you haven't, because you can't actually verify them, just claim
them, because they aren't actually correct.

>
> It is a very 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. Only one reviewer out of 100 reviewers in a dozen
> different forums over the period of a year would acknowledge that.

ONLY if H actually does a correct and complete x86 emulation, which it
actually doesn't, not if it returns 0 for a non-halting input. So, the
statement is actually illogical.

>
> The x86 emulator code is immaculate because I was very cautious in my
> slight changes to keep it very clean. H is the one halt decider that has
> all of its code quite clean and finally a pure function of its inputs.
> The x86utm operating system code is very reliable yet quite messy.

Some how, from what you have shown in the past, I doubt the the code for
H is "clean". I say this based on what code you have published and how
bad the basic structure of the code has been.

>
> At this point I have provided enough evidence that reasonable people
> would conclude that all of my claims of having actual code have been
> sufficiently proven. I decided that posting this code as a Google Drive
> downloadable link to a complete Visual Studio project is the way to go.

>
> The solution is defined so that immediately after the build the halt
> decider can be directly run from inside Visual Studio. The halt decider
> file itself can be edited to run different halt deciders on a small
> library of sample inputs. Right out of the box H(P,P) is executed.
>

And none of this shows that H(P,P) returning 0 is the right answer for H
to give as a Halt Decider, we don't need code to see that, we can go by
definitions.

The DEFINITION of a Halt decider is that it is a computation (so always
gives the same answer for the same inputs) that answer whether a given
algorithm + input combination will halt in a finite number of steps or not.

Typically, the computation to be decided is provided as a representation
of the algorithm and a representation of the input to be given to that
algorithm.

The Halting Theorem states that no such finite algorithm exist that can
be a correct halting decider for all possible algorithm + input
combinations.

The proof, is to imagine that we create a algorithm and input that asks
the proposed Halt Decider what this algorithm will do with its input,
and then do the opposite.

Said algorithm is clearly possible to build, if the halt decider
algorithm exists, as the steps are clearly defined.

Since your P is the embodyment of this counter example algorithm, and
P(P) calls H(P,P), that means that H(P,P) must mean that H(P,P) is
defined to answer about what P(P) does.

You claim otherwise just shows that you just don't understand the proof,
and are just being a dumb parrot about your code pieces and not
understanding them. (One reason I doubt your code is "clean").

Since we can easily prove that P(P) will Halt if H(P,P) returns 0, we
can show that H(P,P) returning 0 is clearly the wrong answer for a P
built by the counter argument algorithm, which is what is claimed.

Thus, either you have lied that this test was actually built to the
specifications (perhaps because you actually don't understand what
specifications actually mean) or your H is just an incorrect algorithm.

"Don't drop acid, take it pass-fail!" -- Bryan Michael Wendt

computers / comp.ai.philosophy / Re: Halting Problem proof refutation is a tautology thus irrefutable [ liar or incompetent ]

Subject	Author
Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus	Mr Flibble
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus	Mr Flibble
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus irrefutable	Richard Damon
Re: Halting Problem proof refutation is a tautology thus irrefutable	Mr Flibble
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus irrefutable	Richard Damon
Re: Halting Problem proof refutation is a tautology thus	Mr Flibble
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus irrefutable	Richard Damon
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus irrefutable	Richard Damon
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus	Mr Flibble
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus	Mr Flibble
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus irrefutable [ strawman	Mr Flibble
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus irrefutable	Richard Damon
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus	Mr Flibble
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus irrefutable	Richard Damon
Re: Halting Problem proof refutation is a tautology thus	Mr Flibble
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus	Mr Flibble
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus irrefutable [ liar or i	Mr Flibble
Re: Halting Problem proof refutation is a tautology thus irrefutable	Richard Damon
Re: Halting Problem proof refutation is a tautology thus	Mr Flibble
Re: Halting Problem proof refutation is a tautology thus irrefutable	Richard Damon
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus irrefutable [ liar or i	Mr Flibble
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus	Mr Flibble
Re: Halting Problem proof refutation is a tautology thus	Mr Flibble
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus	Mr Flibble
Re: Halting Problem proof refutation is a tautology thus irrefutable	Richard Damon
Re: Halting Problem proof refutation is a tautology thus irrefutable	Richard Damon
Re: Halting Problem proof refutation is a tautology thus irrefutable	Richard Damon
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus irrefutable	Richard Damon
Re: Halting Problem proof refutation is a tautology thus irrefutable	Richard Damon
Re: Halting Problem proof refutation is a tautology thus irrefutable	André G. Isaak
Re: Halting Problem proof refutation is a tautology thus	Mr Flibble
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus irrefutable	André G. Isaak
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus irrefutable	André G. Isaak
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus irrefutable	Richard Damon
Re: Halting Problem proof refutation is a tautology thus irrefutable [ technical	olcott
Re: Halting Problem proof refutation is a tautology thus	Mr Flibble
Re: Halting Problem proof refutation is a tautology thus irrefutable	Richard Damon
Re: Halting Problem proof refutation is a tautology thus irrefutable	Richard Damon
Re: Halting Problem proof refutation is a tautology thus irrefutable	Richard Damon
Re: Halting Problem proof refutation is a tautology thus irrefutable	Richard Damon
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus irrefutable [ strawman	Richard Damon
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus irrefutable	Richard Damon
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus irrefutable	Richard Damon
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus irrefutable	Richard Damon
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus irrefutable	Richard Damon
Re: Halting Problem proof refutation is a tautology thus irrefutable	Richard Damon
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus irrefutable	Richard Damon
Re: Halting Problem proof refutation is a tautology thus irrefutable	olcott
Re: Halting Problem proof refutation is a tautology thus irrefutable	Richard Damon
Re: Halting Problem proof refutation is a tautology thus irrefutable	Richard Damon