On 6/17/22 2:59 PM, olcott wrote:
> On 6/17/2022 1:08 PM, Mr Flibble wrote:
>> On Fri, 17 Jun 2022 19:04:51 +0100
>> Mr Flibble <flibble@reddwarf.jmc> wrote:
>>
>>> On Fri, 17 Jun 2022 18:14:48 +0100
>>> Mr Flibble <flibble@reddwarf.jmc> wrote:
>>>
>>>> On Fri, 17 Jun 2022 12:13:13 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>> On 6/17/2022 12:04 PM, Mr Flibble wrote:
>>>>>> On Fri, 17 Jun 2022 11:59:53 -0500
>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>> On 6/17/2022 11:51 AM, Mr Flibble wrote:
>>>>>>>> On Fri, 17 Jun 2022 11:38:29 -0500
>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>> On 6/17/2022 11:36 AM, Mr Flibble wrote:
>>>>>>>>>> On Fri, 17 Jun 2022 11:33:22 -0500
>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>> On 6/17/2022 11:22 AM, Mr Flibble wrote:
>>>>>>>>>>>> On Fri, 17 Jun 2022 11:16:15 -0500
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>> On 6/17/2022 11:14 AM, Mr Flibble wrote:
>>>>>>>>>>>>>> On Fri, 17 Jun 2022 11:12:31 -0500
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>> On 6/17/2022 10:56 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:49:08 -0500
>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>> On 6/17/2022 10:37 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 10:33:59 -0500
>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>> On 6/17/2022 9:56 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>> On Fri, 17 Jun 2022 09:51:07 -0500
>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 9:39 AM, wij wrote:
>>>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 22:19:09 UTC+8,
>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 6/17/2022 8:39 AM, wij wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On Friday, 17 June 2022 at 19:29:37 UTC+8,
>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> When a simulating halt decider rejects all
>>>>>>>>>>>>>>>>>>>>>>>>> inputs as non-halting whenever it correctly
>>>>>>>>>>>>>>>>>>>>>>>>> detects that its correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input would never reach the
>>>>>>>>>>>>>>>>>>>>>>>>> final state of this input then all [these]
>>>>>>>>>>>>>>>>>>>>>>>>> inputs (including pathological inputs) are
>>>>>>>>>>>>>>>>>>>>>>>>> decided correctly.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *computation that halts* … the Turing machine
>>>>>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state.
>>>>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Linz, Peter 1990. An Introduction to Formal
>>>>>>>>>>>>>>>>>>>>>>>>> Languages and Automata. Lexington/Toronto: D.
>>>>>>>>>>>>>>>>>>>>>>>>> C. Heath and Company. (317-320)
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> #include <stdint.h>
>>>>>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>> if (H(x, x))
>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
>>>>>>>>>>>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
>>>>>>>>>>>>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 //
>>>>>>>>>>>>>>>>>>>>>>>>> call H [00001362](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>>>>>>>>>>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>>>>>>>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>>>>>>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>> [0000136c](01) c3 ret
>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> (1) It is an easily verified fact that when
>>>>>>>>>>>>>>>>>>>>>>>>> we assume that H is only an x86 emulator
>>>>>>>>>>>>>>>>>>>>>>>>> that the correctly emulated P never reaches
>>>>>>>>>>>>>>>>>>>>>>>>> its "ret" instruction it remains stuck in
>>>>>>>>>>>>>>>>>>>>>>>>> repeated cycles of emulation.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> (2) It is an easily verified fact that if H
>>>>>>>>>>>>>>>>>>>>>>>>> has been adapted to correctly detect (in a
>>>>>>>>>>>>>>>>>>>>>>>>> finite number of steps) that the correct and
>>>>>>>>>>>>>>>>>>>>>>>>> complete x86 emulation of its input would
>>>>>>>>>>>>>>>>>>>>>>>>> never each its "ret" instruction that H
>>>>>>>>>>>>>>>>>>>>>>>>> could abort its emulation and return 0 to
>>>>>>>>>>>>>>>>>>>>>>>>> report this.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> (3) When the halt status criteria is defined
>>>>>>>>>>>>>>>>>>>>>>>>> as correctly determining whether or not an
>>>>>>>>>>>>>>>>>>>>>>>>> x86 emulated input would ever reach its "ret"
>>>>>>>>>>>>>>>>>>>>>>>>> instruction then it becomes an easily
>>>>>>>>>>>>>>>>>>>>>>>>> verified fact H(P,P) could correctly reject
>>>>>>>>>>>>>>>>>>>>>>>>> its input as non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Correct deductive inference proves that all
>>>>>>>>>>>>>>>>>>>>>>>>> of these things are true without any need
>>>>>>>>>>>>>>>>>>>>>>>>> what-so-ever to see either the source-code or
>>>>>>>>>>>>>>>>>>>>>>>>> the execution trace of H.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The one thing that is not proved is whether
>>>>>>>>>>>>>>>>>>>>>>>>> or not an actual encoded H(P,P) does indeed
>>>>>>>>>>>>>>>>>>>>>>>>> correctly determine that its input would
>>>>>>>>>>>>>>>>>>>>>>>>> never reach its "ret" instruction as a pure
>>>>>>>>>>>>>>>>>>>>>>>>> function of its inputs. This aspect will be
>>>>>>>>>>>>>>>>>>>>>>>>> confirmed by fully operational source-code.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely
>>>>>>>>>>>>>>>>>>>>>>>>> nested simulation (V5)
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> GUR already suggested such a halting decider H
>>>>>>>>>>>>>>>>>>>>>>>> cannot exist:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0 means P(P) does not halt.
>>>>>>>>>>>>>>>>>>>>>>> That is a misconception.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Halt deciders must compute the mapping from
>>>>>>>>>>>>>>>>>>>>>>> their inputs to an accept or reject state on
>>>>>>>>>>>>>>>>>>>>>>> the basis of the actual behavior actually
>>>>>>>>>>>>>>>>>>>>>>> specified by these inputs.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> 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 its "ret"
>>>>>>>>>>>>>>>>>>>>>>> instruction thus conclusively proving that it
>>>>>>>>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==1 means P(P) halts.
>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==Otherwise means H fails as a decider
>>>>>>>>>>>>>>>>>>>>>>>> (undecidable).
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> -----
>>>>>>>>>>>>>>>>>>>>>>>> Thanks to PO's years' tireless efforts
>>>>>>>>>>>>>>>>>>>>>>>> demonstrated even himself a genius in
>>>>>>>>>>>>>>>>>>>>>>>> 10000-years cannot refute my GUR. ...
>>>>>>>>>>>>>>>>>>>>>>> --
>>>>>>>>>>>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> GUR suggests no halting decider can exist. You
>>>>>>>>>>>>>>>>>>>>>> just confirms it by not able to provide POOH to
>>>>>>>>>>>>>>>>>>>>>> test/review.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> It took me six months to figure out how to
>>>>>>>>>>>>>>>>>>>>> transform H(P,P) into a pure function of its
>>>>>>>>>>>>>>>>>>>>> inputs. I did not release the code before because
>>>>>>>>>>>>>>>>>>>>> I knew that its use of static local data would
>>>>>>>>>>>>>>>>>>>>> have been rejected. With this update to H I will
>>>>>>>>>>>>>>>>>>>>> be able to publish the code.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> H recognizes that P is calling itself with its
>>>>>>>>>>>>>>>>>>>>> same arguments that it was called with and there
>>>>>>>>>>>>>>>>>>>>> are no instructions preceding this call that
>>>>>>>>>>>>>>>>>>>>> could possibly escape infinitely recursive
>>>>>>>>>>>>>>>>>>>>> emulation so H aborts its emulation of P before
>>>>>>>>>>>>>>>>>>>>> P even makes its first call to H.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Without even looking at the code competent
>>>>>>>>>>>>>>>>>>>>> software engineers will be able to verify that
>>>>>>>>>>>>>>>>>>>>> the above H would correctly determine that that
>>>>>>>>>>>>>>>>>>>>> is input is non-halting as a pure function of
>>>>>>>>>>>>>>>>>>>>> this input.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> So my other reply for why your H is not a pure
>>>>>>>>>>>>>>>>>>>> function for any accepted definition of the term.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> In computer programming, a pure function is a
>>>>>>>>>>>>>>>>>>> function that has the following properties:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> (1) the function return values are identical for
>>>>>>>>>>>>>>>>>>> identical arguments (no variation with local static
>>>>>>>>>>>>>>>>>>> variables, non-local variables, mutable reference
>>>>>>>>>>>>>>>>>>> arguments or input streams), and
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> (2) the function application has no side effects
>>>>>>>>>>>>>>>>>>> (no mutation of local static variables, non-local
>>>>>>>>>>>>>>>>>>> variables, mutable reference arguments or
>>>>>>>>>>>>>>>>>>> input/output streams).
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Thus a pure function is a computational analogue
>>>>>>>>>>>>>>>>>>> of a mathematical function.
>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The revised H has no:
>>>>>>>>>>>>>>>>>>> (a) local static variables
>>>>>>>>>>>>>>>>>>> (b) non-local variables
>>>>>>>>>>>>>>>>>>> (c) mutable reference arguments
>>>>>>>>>>>>>>>>>>> (d) input streams
>>>>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure
>>>>>>>>>>>>>>>>>> functions do not have side effects.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You have a reading comprehension problem.
>>>>>>>>>>>>>>>>> If H does not have (a)(b)(c)(d) then
>>>>>>>>>>>>>>>>> H has no mutation side effect to (a)(b)(c)(d)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Not at all, but you do seem to have that problem.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Again:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Aborting the simulation is a side effect; pure
>>>>>>>>>>>>>>>> functions do not have side effects.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Whether or not it is construed as a side-effect does
>>>>>>>>>>>>>>> not matter it must be a mutation side-effect to
>>>>>>>>>>>>>>> (a)(b)(c)(d) or it does not count.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It doesn't count according to who?
>>>>>>>>>>>>>
>>>>>>>>>>>>> The above definition of pure functions.
>>>>>>>>>>>>
>>>>>>>>>>>> "In computer science, an operation, function or expression
>>>>>>>>>>>> is said to have a side effect if it modifies some state
>>>>>>>>>>>> variable value(s) outside its local environment,
>>>>>>>>>>>
>>>>>>>>>>> The second part is an inaccurate paraphrase of the first
>>>>>>>>>>> part.
>>>>>>>>>>>> which is to say if it has any observable effect
>>>>>>>>>>>> other than its primary effect of returning a value to the
>>>>>>>>>>>> invoker of the operation." --
>>>>>>>>>>>> https://en.wikipedia.org/wiki/Side_effect_(computer_science)
>>>>>>>>>>>>
>>>>>>>>>>>> "any observable effect"
>>>>>>>>>>>>
>>>>>>>>>>>> Aborting the simulation instead of returning a value to
>>>>>>>>>>>> the invoker disqualifies it from being a pure function.
>>>>>>>>>>>>
>>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>> {
>>>>>>>>>>>        if (H(x, x))
>>>>>>>>>>>          HERE: goto HERE;
>>>>>>>>>>>        return;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> int main()
>>>>>>>>>>> {
>>>>>>>>>>>        Output("Input_Halts = ", H(P, P));
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> _P()
>>>>>>>>>>> [00001352](01)  55              push ebp
>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp
>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>>>> [00001358](01)  50              push eax      // push P
>>>>>>>>>>> [00001359](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>>>> [0000135c](01)  51              push ecx      // push P
>>>>>>>>>>> [0000135d](05)  e840feffff      call 000011a2 // call H
>>>>>>>>>>> [00001362](03)  83c408          add esp,+08
>>>>>>>>>>> [00001365](02)  85c0            test eax,eax
>>>>>>>>>>> [00001367](02)  7402            jz 0000136b
>>>>>>>>>>> [00001369](02)  ebfe            jmp 00001369
>>>>>>>>>>> [0000136b](01)  5d              pop ebp
>>>>>>>>>>> [0000136c](01)  c3              ret
>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>
>>>>>>>>>>> H aborts its x86 emulation of P as soon P reaches its
>>>>>>>>>>> machine address of [0000135d] the very first time before
>>>>>>>>>>> the code at this address is emulated. Then H returns 0 to
>>>>>>>>>>> its caller: main().
>>>>>>>>>>
>>>>>>>>>> Returning to main() is not returning to its invoker, P.
>>>>>>>>>>
>>>>>>>>>> Again:
>>>>>>>>>>
>>>>>>>>>> Aborting the simulation is a side effect; pure functions do
>>>>>>>>>> not have side effects.
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>> Do you have ADD?
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>>        Output("Input_Halts = ", H(P, P));
>>>>>>>>> }
>>>>>>>> If your claim is that H is only called once and the second
>>>>>>>> time an *attempt* to call H is prevented than that is
>>>>>>>> equivalent to calling H and having H do something different
>>>>>>>> with side effects. This is just my opinion though as it
>>>>>>>> requires more thought and I am currently getting drunk on gin
>>>>>>>> and tonics.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>
>>>>>>> It is obviously the exact same pattern as infinite recursion
>>>>>>> (a) calling the same function a second time with the same
>>>>>>> arguments and
>>>>>>>
>>>>>>> (b) there are no instructions preceding this call that could
>>>>>>> possibly escape the infinite recursion / infinitely recursive
>>>>>>> emulation.
>>>>>> Agree but refusing to analyse what P would have done if H
>>>>>> wasn't a simulating decider still makes what you've got
>>>>>> worthless as far as the Halting Problem is concerned.
>>>>>>
>>>>>> /Flibble (getting drunk, possibly not quite at Ballmer's Peak)
>>>>>
>>>>> It is dead obvious to everyone (even Richard) that what P would
>>>>> have done if H was merely an x86 emulator and not a halt deciding
>>>>> emulator.
>>>>>
>>>>> The correct and complete x86 emulation of H(P,P) would never reach
>>>>> its "ret" instruction thus making H a correct "not reach ret" /
>>>>> halt decider for P.
>>>>
>>>> You need to think about a P that calls H but is non-pathological
>>>> halting (no infinite loop).
>>>
>>> Your assumption that any program that calls H is also pathological is
>>> a flawed one.  I have said before that all you have is a simulation
>>> detector and not a halt decider: simulating halt deciders cannot
>>> decide non-pathological non-halting programs in finite time so are not
>>> actually deciders.
>>
>> The question then becomes is a simulation detector (rather than a halt
>> decider) sufficient to refute proofs based on the [Strachey 1965]
>> impossible program?  I cannot answer that question as I am unfamiliar
>> with the proofs.
>>
>> /Flibble
>>
>
> [Strachey 1965] is merely P that takes no arguments and H that takes one
> argument.
>
> void P0()
> {
>   if (H0((u32)P0))
>     HERE: goto HERE;
>   return;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H0((u32)P0));
> }
>
> _P0()
> [00001396](01)  55              push ebp
> [00001397](02)  8bec            mov ebp,esp
> [00001399](05)  6896130000      push 00001396
> [0000139e](05)  e813fdffff      call 000010b6
> [000013a3](03)  83c404          add esp,+04
> [000013a6](02)  85c0            test eax,eax
> [000013a8](02)  7402            jz 000013ac
> [000013aa](02)  ebfe            jmp 000013aa
> [000013ac](01)  5d              pop ebp
> [000013ad](01)  c3              ret
> Size in bytes:(0024) [000013ad]
>
> _main()
> [000013b6](01)  55              push ebp
> [000013b7](02)  8bec            mov ebp,esp
> [000013b9](05)  6896130000      push 00001396
> [000013be](05)  e8f3fcffff      call 000010b6
> [000013c3](03)  83c404          add esp,+04
> [000013c6](01)  50              push eax
> [000013c7](05)  6827040000      push 00000427
> [000013cc](05)  e8a5f0ffff      call 00000476
> [000013d1](03)  83c408          add esp,+08
> [000013d4](02)  33c0            xor eax,eax
> [000013d6](01)  5d              pop ebp
> [000013d7](01)  c3              ret
> Size in bytes:(0034) [000013d7]
>
>  machine   stack     stack     machine    assembly
>  address   address   data      code       language
>  ========  ========  ========  =========  =============
> ...[000013b6][0010230c][00000000] 55              push ebp
> ...[000013b7][0010230c][00000000] 8bec            mov ebp,esp
> ...[000013b9][00102308][00001396] 6896130000      push 00001396
> ...[000013be][00102304][000013c3] e8f3fcffff      call 000010b6
>
> Begin Local Halt Decider Simulation   Execution Trace Stored at:2123c0
> ...[00001396][002123b0][002123b4] 55              push ebp
> ...[00001397][002123b0][002123b4] 8bec            mov ebp,esp
> ...[00001399][002123ac][00001396] 6896130000      push 00001396
> ...[0000139e][002123a8][000013a3] e813fdffff      call 000010b6
> ...[00001396][0025cdd8][0025cddc] 55              push ebp
> ...[00001397][0025cdd8][0025cddc] 8bec            mov ebp,esp
> ...[00001399][0025cdd4][00001396] 6896130000      push 00001396
> ...[0000139e][0025cdd0][000013a3] e813fdffff      call 000010b6
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>
> ...[000013c3][0010230c][00000000] 83c404          add esp,+04
> ...[000013c6][00102308][00000000] 50              push eax
> ...[000013c7][00102304][00000427] 6827040000      push 00000427
> ---[000013cc][00102304][00000427] e8a5f0ffff      call 00000476
> Input_Halts = 0
> ...[000013d1][0010230c][00000000] 83c408          add esp,+08
> ...[000013d4][0010230c][00000000] 33c0            xor eax,eax
> ...[000013d6][00102310][00100000] 5d              pop ebp
> ...[000013d7][00102314][00000004] c3              ret
> Number of Instructions Executed(11031)
>
>

So why can H validly conclude that P() doesn't halt when it calls H(P)
when we know that H(P) returns 0 in finite time?

Same error.