On 6/19/2022 6:27 PM, Mr Flibble wrote:
> On Sun, 19 Jun 2022 18:25:33 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/19/2022 5:58 PM, Mr Flibble wrote:
>>> On Sun, 19 Jun 2022 18:53:36 -0400
>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>
>>>> On 6/19/22 6:22 PM, Mr Flibble wrote:
>>>>> On Sun, 19 Jun 2022 17:16:03 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/19/2022 4:46 PM, Mr Flibble wrote:
>>>>>>> On Sun, 19 Jun 2022 16:23:17 -0500
>>>>>>> olcott <NoOne@NoWhere.com> 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
>>>>>>>
>>>>>>> What I am saying is the following, no more, no less:
>>>>>>>
>>>>>>> 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
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> You are not committing to a criterion measure of correctness thus
>>>>>> your claim is vague.
>>>>>
>>>>> Vague? My "claim" is crystal clear: Px should ALWAYS HALT and
>>>>> your H decides that it is non-halting.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> Flibble, Px doesn't "Always" Halt. If H(Px,Px) doesn't return
>>>> because it gets stuck in an infinite loop, then Px(Px) doesn't
>>>> Halt.
>>>>
>>>> Now, this H fails to be a decider, so can't be a counter example
>>>> for a Halt Decider.
>>>
>>> If H is a valid halt decider (and by that I mean returns an answer
>>> in finite time) then Px *will* always halt: it doesn't because
>>> Olcott's H is not a valid halt decider.
>>>
>>> /Flibble
>>>
>>
>> Now that H has been very recently adapted to be a pure function of
>> its inputs whenever it is invoked it always returns on finite time.
>> H aborts its simulation of Px before Px invokes H.
>>
>> 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 its call to H is invoked.
>
> 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
>

So you are a mere bot now.

--
Copyright 2022 Pete Olcott

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