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