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.

--
Copyright 2022 Pete Olcott

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