Proof that H(P,P)==0 is correct [ refuting the halting problem proofs ]

[olcott]

(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 Instructions Executed(15892) lines = 237 pages


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

[olcott]

On 5/10/2022 10:50 AM, Ben wrote:

> olcott <No...@NoWhere.com> writes:
>
>> (a) Verify that the execution trace of P by H is correct by comparing
>> this execution trace to the ax86 source-code of P.
>

> P called with what argument? I assume P.

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

> Something is wrong in your code if P(P), or a simulation of P(P), does
> not halt, since you told us that it does. Post the code and someone
> will help you find the bug.

>
>> #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));
>> }
>

> Unless you are retracting any of the facts you have previously stated,
> we know (because you've told us) that H(P,P) returns 0 and we know
> (because you've told us) that P(P) halts. The trace of the execution
> will either confirm this, or the trace is faulty. Nothing new can come
> from looking at traces of mystery code.
>

(a) The trace is verifiably correct if one has the technical skill.
(b) The trace is proved non-halting if one has the technical skill.
You simply don't seem to have the technical skill.

I PUT BACK IN THE MANDATORY DETAILS THAT PROVE MY POINT THAT YOU ERASED.

[Richard Damon]

No, it is verifiably INCORRECT for one with even a tiny bit of skill.

> (b) The trace is proved non-halting if one has the technical skill.
> You simply don't seem to have the technical skill.
>

Nope, the trace proves you are LYING about actually simulating the input.

Trace breaks here. A CORRECT Trace would now trace the operation of the
copy of H that P is using.

Also, the following never happens as code in the call to H unless H just
calls its input at which point it can't 'abort' this 'simuation'

> ...[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
>

Thus proving that H didn't just call its input (or the H being called by
P isn't the same as the H deciding on H(P,P) and thus you are lying
about build P correctly.

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

FALSE. YOU are forgetting that the H being called will (if it is the
same code as the H deciding) will also abort its simulation, thus
breaking the "infinite recursion", thus the proof is UNSOUND.

[olcott]

On 5/11/2022 2:54 PM, Ben wrote:
> olcott <No...@NoWhere.com> writes:
>
>> On 5/10/2022 10:50 AM, Ben wrote:
>>> olcott <No...@NoWhere.com> writes:
>>>

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

>>> P called with what argument? I assume P.

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

>>> Something is wrong in your code if P(P), or a simulation of P(P), does
>>> not halt, since you told us that it does. Post the code and someone
>>> will help you find the bug.
>>

>> If you had the technical skill you could verify that it is 100%
>> impossible for there to be anything wrong with the code on the basis
>> of that of the verifiably correct execution trace that it derives.
>
> You trace clearly and accurately shows that what you call the
> "simulation of the input" is wrong.
>

That is utter nonsense.
We can see that H(P,P) does execute a pure simulation of its input on
the basis of the execution trace of P (up to the point where P would
call H a second time from its same machine address with identical
parameters) provided by H and the x86 source code of P.

The first seven machine instructions of P from [00001352] to [0000135d]
are proven to be correctly simulated in sequence, until P calls H(P,P)
which repeats this process.

_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]

Execution trace of the simulation of the input to H(P,P) by H

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============

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

The new simulation gets a new stack giving it a new value for ESP
[00212332] of the prior simulation becomes [0025cd6a] in the new
simulation.

...[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

For the last several weeks it has always been your provably incorrect
opinions against my provably verified facts.

> H(P,P) == false is wrong because P(P) halts. H is supposed to be able
> to tell us which calls terminate and which ones won't. Your H is wrong
> by definition.