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
>

On 6/19/22 3:17 PM, olcott 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.

On 6/19/22 4:05 PM, olcott 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

On 6/19/22 3:23 PM, olcott 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?

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.

Click here to read the complete article

On 6/19/2022 3:19 PM, Richard Damon wrote:
>
> On 6/19/22 3:17 PM, olcott 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.
>
> What "Future Tense".
A halt decider must always correctly determine whether or not its input
WOULD halt. If halt deciders reported what the behavior of its input
DOES then like you said it would never report on non halting inputs.

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
>
>

On 6/19/22 4:34 PM, olcott wrote:
> On 6/19/2022 3:19 PM, Richard Damon wrote:
>>
>> On 6/19/22 3:17 PM, olcott 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.
>>
>> What "Future Tense".
> A halt decider must always correctly determine whether or not its input
> WOULD halt. If halt deciders reported what the behavior of its input
> DOES then like you said it would never report on non halting inputs.
>
> All non-simulating halt deciders can only report on what their input
> WOULD do and not what their input DOES because non-simulating halt
> deciders are static rather than dynamic analyzers.
>

On 6/19/2022 3:50 PM, Richard Damon wrote:
> On 6/19/22 4:34 PM, olcott wrote:
>> On 6/19/2022 3:19 PM, Richard Damon wrote:
>>>
>>> On 6/19/22 3:17 PM, olcott 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.
>>>
>>> What "Future Tense".
>> A halt decider must always correctly determine whether or not its
>> input WOULD halt. If halt deciders reported what the behavior of its
>> input
>> DOES then like you said it would never report on non halting inputs.
>>
>> All non-simulating halt deciders can only report on what their input
>> WOULD do and not what their input DOES because non-simulating halt
>> deciders are static rather than dynamic analyzers.
>>
>
> Would only in the sense of condition of testing, not time.
Halt deciders must always predict what their non-halting inputs would do
in the future if they were executed.

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.
>

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.
>

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.

Click here to read the complete article

On 6/19/22 4:55 PM, olcott wrote:
> On 6/19/2022 3:50 PM, Richard Damon wrote:
>> On 6/19/22 4:34 PM, olcott wrote:
>>> On 6/19/2022 3:19 PM, Richard Damon wrote:
>>>>
>>>> On 6/19/22 3:17 PM, olcott 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.
>>>>
>>>> What "Future Tense".
>>> A halt decider must always correctly determine whether or not its
>>> input WOULD halt. If halt deciders reported what the behavior of its
>>> input
>>> DOES then like you said it would never report on non halting inputs.
>>>
>>> All non-simulating halt deciders can only report on what their input
>>> WOULD do and not what their input DOES because non-simulating halt
>>> deciders are static rather than dynamic analyzers.
>>>
>>
>> Would only in the sense of condition of testing, not time.
> Halt deciders must always predict what their non-halting inputs would do
> in the future if they were executed.

On 6/19/2022 4:20 PM, Mr Flibble wrote:
> 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

On 6/19/22 5:17 PM, olcott 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

On 6/19/2022 4:23 PM, Richard Damon wrote:
>
> On 6/19/22 4:55 PM, olcott wrote:
>> On 6/19/2022 3:50 PM, Richard Damon wrote:
>>> On 6/19/22 4:34 PM, olcott wrote:
>>>> On 6/19/2022 3:19 PM, Richard Damon wrote:
>>>>>
>>>>> On 6/19/22 3:17 PM, olcott 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.
>>>>>
>>>>> What "Future Tense".
>>>> A halt decider must always correctly determine whether or not its
>>>> input WOULD halt. If halt deciders reported what the behavior of its
>>>> input
>>>> DOES then like you said it would never report on non halting inputs.
>>>>
>>>> All non-simulating halt deciders can only report on what their input
>>>> WOULD do and not what their input DOES because non-simulating halt
>>>> deciders are static rather than dynamic analyzers.
>>>>
>>>
>>> Would only in the sense of condition of testing, not time.
>> Halt deciders must always predict what their non-halting inputs would
>> do in the future if they were executed.
>
> Why?
>
> There is no actual requirement to execute the machine, only know what
> would happen if at some point we did do that execution either in the
> past or the future.
>
>>
>> They can never report on the non-halting behavior of what their inputs
>> did do in the past.
>
> Why not?

On 6/19/22 5:23 PM, olcott wrote:
> On 6/19/2022 4:20 PM, Mr Flibble wrote:
>> 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
>
>
> DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
> the correct and complete x86 emulation of the input to H(Px,Px) by H
> would never reach the "ret" instruction
>

On 6/19/2022 4:30 PM, Richard Damon wrote:
>
> On 6/19/22 5:17 PM, olcott 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 did you verify this statment for an H that returns 0?
>