XPost: comp.theory, sci.logic

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

olcott <NoOne@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.

#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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 5/11/22 12:47 AM, olcott wrote:

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

olcott <NoOne@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.

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.

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

#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

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.

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

On 5/11/2022 2:54 PM, Ben wrote:

olcott <NoOne@NoWhere.com> writes:

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

olcott <NoOne@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.

--
Copyright 2022 Pete Olcott

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)