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.

You just don't understand what you are saying, showing that you are NOT
a "Competent Software Engineer" I guess.

Sorry Charlie, we only really want the Truth, and that is truth that
matches the actual definitions.

H(M,x) needs to accept this input if M(x) Halts, and Reject if M(x)
never halts.

If you H(Px,Px) creates a non-halting input then that means that
H(Px,Px) never returned an answer, so failed to meet the definition.

If H(Px,Px) returned ANY answer, then by simple inspection we can see
that Px(Px) will Halt.

Thus, H is incorrect in returning a 0 value, just as it would be
incorrect to not return any value, so, you method is shown to fail for
this case.

Possible causes are H isn't actually a computation and thus behaves
differently for the same input in different environments, or H is just
not correct in its logic.

FAIL.