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.

--
Copyright 2022 Pete Olcott

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