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.

--
Copyright 2022 Pete Olcott

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