Re: On Strachey [ How nuts is that? ][ proof that I am correct ]

[olcott]

On 5/9/2022 6:42 PM, wij wrote:
> On Tuesday, 10 May 2022 at 07:31:07 UTC+8, olcott wrote:
>> On 5/9/2022 6:23 PM, wij wrote:
>>> On Tuesday, 10 May 2022 at 07:20:03 UTC+8, olcott wrote:
>>>> On 5/9/2022 6:11 PM, wij wrote:
>>>>> On Tuesday, 10 May 2022 at 07:03:08 UTC+8, olcott wrote:
>>>>>> On 5/9/2022 5:53 PM, wij wrote:
>>>>>>> On Tuesday, 10 May 2022 at 06:44:15 UTC+8, olcott wrote:
>>>>>>>> On 5/9/2022 5:34 PM, wij wrote:
>>>>>>>>> On Tuesday, 10 May 2022 at 06:18:31 UTC+8, olcott wrote:
>>>>>>>>>> On 5/9/2022 4:51 PM, wij wrote:
>>>>>>>>>>> On Tuesday, 10 May 2022 at 05:20:02 UTC+8, olcott wrote:
>>>>>>>>>>>> On 5/9/2022 3:59 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Monday, May 9, 2022 at 4:51:57 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 5/9/2022 3:27 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Monday, May 9, 2022 at 4:18:04 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 5/9/2022 12:26 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Monday, May 9, 2022 at 1:18:28 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>> On 5/9/2022 11:52 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>> On Monday, May 9, 2022 at 12:39:59 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 5/9/2022 11:30 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>> On Monday, May 9, 2022 at 12:06:01 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 5/9/2022 11:02 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Monday, May 9, 2022 at 11:31:16 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2022 9:36 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 10:20:27 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2022 8:26 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 9:08:33 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2022 7:48 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 8:19:40 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2022 6:35 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 7:14:57 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2022 5:47 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/6/2022 8:07 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/6/2022 7:11 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The halting theorem follows, trivially, from lots of simpler theorems,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> none of which have you bothered to read. In Linz, the theorem is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> presented as a corollary of a simpler theorem in chapter 11.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 11.3, 11.4, and 11.5. I will look at them.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Goodness! A good move. Why the change of heart?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There is enough progress now that I don't have to have an absolutely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> single-minded focus.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Progress?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THIS IS AN EASILY VERIFIABLE FACT:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Both H() and H1() take the machine code of P as input parameters and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly compute the mapping from this input to an accept ore reject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state on the basis of the actual behavior that these inputs actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specify.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But H does not decide the halting of P(P).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int sum(int N , int M)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return (N + M);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is not supposed to in the same way that sum(3,4) is not supposed to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> provide the sum of (5,7).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Why is this so difficult for you?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You know that if anyone insisted that sum(3,4) must return the value of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sum(5,7) that they are wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then why do you insist that H(P,P) must return the value of H(Pn,Pn)?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The definition of decider requires it to based its decision on whatever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input specifies.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Which in the case of H(P,P) is *defined* to be P(P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> In this case it is the same as if {dogs} are defined to be {cats}.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> So no rebuttal, just a bad analogy.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Both H(P,P) and H1(P,P) use this exact literal byte string as their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input therefore it seems enormously dishonest of you to refer to the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same literal string using different subscripts indicating a difference
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the same string with itself.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What I was saying is that you think that H sees infinite simulation which only exists in Pn(Pn)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> All that crazy bullshit about subscripted names of subscripts is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> extremely deceptive
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> No, just the opposite. It makes it clear *exactly* which computation we're talking about, so it prevents YOU from being deceptive.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> I am ONLY referring to this literal string:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>>>>>>>>>>>>>>> as x86 machine code correctly simulated by H(P,P) and H1(P,P).
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> No you're not. You're also referring to the literal string which is the fixed code of H which aborts as that is part of the program P. So from here on, we'll refer to H as Ha and P as Pa to make that point clear.
>>>>>>>>>>>>>>>>>>>>>>>>>> I am only referring to this literal string:
>>>>>>>>>>>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> as an input to H(P,P) and H1(P,P). It is 100% perfectly concrete
>>>>>>>>>>>>>>>>>>>>>>>>>> thus
>>>>>>>>>>>>>>>>>>>>>>>>>> utterly impervious to even extremely well-crafted attempts at deception
>>>>>>>>>>>>>>>>>>>>>>>>>> through the strawman error. Any attempt to get around this will be
>>>>>>>>>>>>>>>>>>>>>>>>>> construed as (and labeled) a bald-faced lie by a bald-faced liar.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> That string is 100% NOT concrete because it doesn't specify the function that it is calling.
>>>>>>>>>>>>>>>>>>>>>>>> I did not freaking say that this finite string specifies every freaking
>>>>>>>>>>>>>>>>>>>>>>>> detail of the whole freaking system nitwit. This finite string as x86
>>>>>>>>>>>>>>>>>>>>>>>> code specifies every one of its own bytes.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Not the whole system, just the computation to be decided on, and that computation includes the FIXED code of H that aborts its simulation, i.e. Ha.
>>>>>>>>>>>>>>>>>>>>>> Thee is no Pa, Pb, Pc, there is only this P:
>>>>>>>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So if that's enough information to decide on, then tell me if this halts:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> void F()
>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>> X()
>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I am only talking about H(P,P) and H1(P,P) where P is this literal
>>>>>>>>>>>>>>>>>>>> string as x86 machine language:
>>>>>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Again, not a complete computation, so not enough information to decide on. You seem to think that all "P" constructs are the same no matter how different the H it is built on is.
>>>>>>>>>>>>>>>>>> Within the context of my paper it is a complete computation for H(P,P).
>>>>>>>>>>>>>>>>>> I am updating the paper to include H1(P,P).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So if H is the *specific* decider that can detect infinite simulation in Pn(Pn), then we'll refer to it as Ha to clarify that point, and we'll refer to the P that calls it as Pa to clarify.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I am talking about the literal string of "H" being applied to this
>>>>>>>>>>>>>>>> literal string: 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The literal string of "H1" being applied to this literal string:
>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And to complete the computation being evaluated, what is the *exact*, FIXED algorithm of H? If it is Ha, then Ha(Pa,Pa) == false is wrong as demonstrated by Hb(Pa,Pa) == true.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If H is using some other algorithm, then specify the *exact* algorithm.
>>>>>>>>>>>>>> H and H1 are both literal byte strings that emulate their literal byte
>>>>>>>>>>>>>> string input in pure x86 emulation mode until the behavior of this
>>>>>>>>>>>>>> emulated literal byte string input shows that it would never reach its
>>>>>>>>>>>>>> own final state (0xc3 ret instruction).
>>>>>>>>>>>>>
>>>>>>>>>>>>> So in other words, the fixed algorithm of H looks for what it thinks is infinite simulation. So H is Ha, which means P is Pa.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Hb can then be constructed to simulate for k more steps than Ha and calculate Hb(Pa,Pa) == true, proving Ha(Pa,Pa) == false wrong.
>>>>>>>>>>>> Begin Local Halt Decider Simulation
>>>>>>>>>>>> machine stack stack machine assembly
>>>>>>>>>>>> address address data code language
>>>>>>>>>>>> ======== ======== ======== ========= =============
>>>>>>>>>>>> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
>>>>>>>>>>>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
>>>>>>>>>>>> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>> ...[000009dc][00211364][000009d6] 50 push eax // Push P
>>>>>>>>>>>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
>>>>>>>>>>>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
>>>>>>>>>>>> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
>>>>>>>>>>>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
>>>>>>>>>>>> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
>>>>>>>>>>>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
>>>>>>>>>>>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
>>>>>>>>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>>>>>>>>>>
>>>>>>>>>>>> The fact that P calls the same function from its same machine address
>>>>>>>>>>>> with identical input parameters conclusively proves that P is stuck in
>>>>>>>>>>>> infinite recursion.
>>>>>>>>>>>> --
>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>
>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>
>>>>>>>>>>> Your coding is invalid, because H is now shown to exist.
>>>>>>>>>> I provide all of the details proving that this H does exist.
>>>>>>>>>
>>>>>>>>> Sorry, I don't think anyone had ever seen one.
>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>>>
>>>>>>> "H is here" does not mean "I provide all of the details proving that this H does exist."
>>>>>>> Where is your H that can stand the HP test?
>>>>>> We can verify that H(P,P) correctly emulates its input on the basis that
>>>>>> the execution trace provided by H exactly matches the behavior specified
>>>>>> by the x86 source-code of 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
>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>> [0000135c](01) 51 push ecx
>>>>>> [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]
>>>>>>
>>>>>> The execution trace that H(P,P) bases its halt status decision on
>>>>>> Begin Local Halt Decider Simulation Execution Trace Stored at:25cd7a
>>>>>> ...[00001352][0025cd66][0025cd6a] 55 push ebp // enter P
>>>>>> ...[00001353][0025cd66][0025cd6a] 8bec mov ebp,esp
>>>>>> ...[00001355][0025cd66][0025cd6a] 8b4508 mov eax,[ebp+08]
>>>>>> ...[00001358][0025cd62][00001352] 50 push eax
>>>>>> ...[00001359][0025cd62][00001352] 8b4d08 mov ecx,[ebp+08]
>>>>>> ...[0000135c][0025cd5e][00001352] 51 push ecx
>>>>>> ...[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H
>>>>>> ...[00001352][002a778e][002a7792] 55 push ebp // enter P
>>>>>> ...[00001353][002a778e][002a7792] 8bec mov ebp,esp
>>>>>> ...[00001355][002a778e][002a7792] 8b4508 mov eax,[ebp+08]
>>>>>> ...[00001358][002a778a][00001352] 50 push eax // push P
>>>>>> ...[00001359][002a778a][00001352] 8b4d08 mov ecx,[ebp+08]
>>>>>> ...[0000135c][002a7786][00001352] 51 push ecx // push P
>>>>>> ...[0000135d][002a7782][00001362] e840feffff call 000011a2 // call H
>>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>>>> H sees that P is calling the same function from the same machine address
>>>>>> with identical parameters, twice in sequence. This is the infinite
>>>>>> recursion non-halting behavior pattern.
>>>>>> --
>>>>>> Copyright 2022 Pete Olcott
>>>>>>
>>>>>> "Talent hits a target no one else can hit;
>>>>>> Genius hits a target no one else can see."
>>>>>> Arthur Schopenhauer
>>>>>
>>>>> This is not H (a halting decider).
>>>> It does correctly decide the one "impossible" input basis of all of the
>>>> proofs, thus refuting all of these proofs.
>>>
>>> "it" does not exist. Show your POOH.
>>>
>>> To refute HP, a H has to exist to refute. If H does not exist, no real rebuttal exist.
>> There is no need to show the hundreds of pages of source code for H
>> (including the open source x86 emulator) or the hundreds of pages of
>> execution trace of H because it is easily verified that:
>
> You choose to refute the conventional HP, and says that there is no need to show
> the hundreds of pages of H...,etc. How do you expect the reviewer/the world
> to verify POOH (a claim?) by 'claim'?
>

(a) Verify that the execution trace of P by H is correct by comparing
this execution trace to the ax86 source-code of P.

(b) Verify that this execution trace shows that P is stuck in infinitely
nested simulation (a non-halting behavior).

#include <stdint.h>
#define u32 uint32_t

void P(u32 x)
{
if (H(x, x))
HERE: goto HERE;
return;
}

int main()
{
Output("Input_Halts = ", H((u32)P, (u32)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
[00001359](03) 8b4d08 mov ecx,[ebp+08]
[0000135c](01) 51 push ecx
[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]

_main()
[00001372](01) 55 push ebp
[00001373](02) 8bec mov ebp,esp
[00001375](05) 6852130000 push 00001352 // push P
[0000137a](05) 6852130000 push 00001352 // push P
[0000137f](05) e81efeffff call 000011a2 // call H
[00001384](03) 83c408 add esp,+08
[00001387](01) 50 push eax
[00001388](05) 6823040000 push 00000423 // "Input_Halts = "
[0000138d](05) e8e0f0ffff call 00000472 // call Output
[00001392](03) 83c408 add esp,+08
[00001395](02) 33c0 xor eax,eax
[00001397](01) 5d pop ebp
[00001398](01) c3 ret
Size in bytes:(0039) [00001398]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
...[00001372][0010229e][00000000] 55 push ebp
...[00001373][0010229e][00000000] 8bec mov ebp,esp
...[00001375][0010229a][00001352] 6852130000 push 00001352 // push P
...[0000137a][00102296][00001352] 6852130000 push 00001352 // push P
...[0000137f][00102292][00001384] e81efeffff call 000011a2 // call H

Begin Local Halt Decider Simulation Execution Trace Stored at:212352
...[00001352][0021233e][00212342] 55 push ebp // enter P
...[00001353][0021233e][00212342] 8bec mov ebp,esp
...[00001355][0021233e][00212342] 8b4508 mov eax,[ebp+08]
...[00001358][0021233a][00001352] 50 push eax // push P
...[00001359][0021233a][00001352] 8b4d08 mov ecx,[ebp+08]
...[0000135c][00212336][00001352] 51 push ecx // push P
...[0000135d][00212332][00001362] e840feffff call 000011a2 // call H
...[00001352][0025cd66][0025cd6a] 55 push ebp // enter P
...[00001353][0025cd66][0025cd6a] 8bec mov ebp,esp
...[00001355][0025cd66][0025cd6a] 8b4508 mov eax,[ebp+08]
...[00001358][0025cd62][00001352] 50 push eax // push P
...[00001359][0025cd62][00001352] 8b4d08 mov ecx,[ebp+08]
...[0000135c][0025cd5e][00001352] 51 push ecx // push P
...[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

H sees that P is calling the same function from the same machine address
with identical parameters, twice in sequence. This is the infinite
recursion (infinitely nested simulation) non-halting behavior pattern.

...[00001384][0010229e][00000000] 83c408 add esp,+08
...[00001387][0010229a][00000000] 50 push eax
...[00001388][00102296][00000423] 6823040000 push 00000423 //
"Input_Halts = "
---[0000138d][00102296][00000423] e8e0f0ffff call 00000472 // call Output
Input_Halts = 0
...[00001392][0010229e][00000000] 83c408 add esp,+08
...[00001395][0010229e][00000000] 33c0 xor eax,eax
...[00001397][001022a2][00100000] 5d pop ebp
...[00001398][001022a6][00000004] c3 ret
Number_of_User_Instructions(1)
Number of Instructions Executed(15892)


>> H(P,P) correctly emulates its input on the basis that the execution
>> trace provided by H exactly matches the behavior specified by the x86
>> source-code of P.
>> It is also easy to verify that this trace specifies the infinite
>> behavior pattern of P:
>> H sees that P is calling the same function from the same machine address
>> with identical parameters, twice in sequence. This is the infinite
>> recursion non-halting behavior pattern.
>
> Invalid claim. Because H is not shown to exist.
>
>>
>>
>> --
>> Copyright 2022 Pete Olcott
>>
>> "Talent hits a target no one else can hit;
>> Genius hits a target no one else can see."
>> Arthur Schopenhauer


--
Copyright 2022 Pete Olcott

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