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