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

When X is a cat then we know that X is an animal.
What if X is a white cat?

the correct and complete x86 emulation of the input to H(Px,Px) by H
would never reach the "ret" instruction

This is a truism thus remains true under all possible conditions.

--
Copyright 2022 Pete Olcott

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