XPost: comp.theory, sci.logic, sci.math

On 5/30/2022 2:17 PM, André G. Isaak wrote:

On 2022-05-30 11:59, olcott wrote:

On 5/30/2022 11:56 AM, André G. Isaak wrote:

A *correct* emulation of P(P) would emulate the exact same sequence
of instructions that occurs when you run P(P) directly,

This is factually incorrect.

How exactly? How would *you* define "correct emulation" if not as above?
You can propose whatever definition you want, but unless the rest of the world accepts your definition you're not going to get anywhere.

The first seven instructions are the same.
The next instructions are not the same.

Yes. They diverge. That's what it MEANS to be an INcorrect emulation.

The x86 source-code of P proves that they must diverge.
When the executed P(P) calls H(P,P) it must return to P.

When the simulated input to H(P,P) calls H(P,P) it cannot return to P
because it keeps simulating the same first seven instructions of P until aborted.

This would be clear to everyone with sufficient technical competence.
This would be clear to everyone with sufficient technical competence.
This would be clear to everyone with sufficient technical competence.
This would be clear to everyone with sufficient technical competence.
This would be clear to everyone with sufficient technical competence.

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

int main()
{
P(P);
}

_P()
[00001341](01) 55 push ebp
[00001342](02) 8bec mov ebp,esp
[00001344](03) 8b4508 mov eax,[ebp+08]
[00001347](01) 50 push eax
[00001348](03) 8b4d08 mov ecx,[ebp+08]
[0000134b](01) 51 push ecx
[0000134c](05) e840feffff call 00001191
[00001351](03) 83c408 add esp,+08
[00001354](02) 85c0 test eax,eax
[00001356](02) 7402 jz 0000135a
[00001358](02) ebfe jmp 00001358
[0000135a](01) 5d pop ebp
[0000135b](01) c3 ret
Size in bytes:(0027) [0000135b]

_main()
[00001361](01) 55 push ebp
[00001362](02) 8bec mov ebp,esp
[00001364](05) 6841130000 push 00001341
[00001369](05) e8d3ffffff call 00001341
[0000136e](03) 83c404 add esp,+04
[00001371](02) 33c0 xor eax,eax
[00001373](01) 5d pop ebp
[00001374](01) c3 ret
Size in bytes:(0020) [00001374]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= ============= ...[00001361][0010224a][00000000] 55 push ebp ...[00001362][0010224a][00000000] 8bec mov ebp,esp ...[00001364][00102246][00001341] 6841130000 push 00001341 ...[00001369][00102242][0000136e] e8d3ffffff call 00001341 ...[00001341][0010223e][0010224a] 55 push ebp ...[00001342][0010223e][0010224a] 8bec mov ebp,esp ...[00001344][0010223e][0010224a] 8b4508 mov eax,[ebp+08] ...[00001347][0010223a][00001341] 50 push eax ...[00001348][0010223a][00001341] 8b4d08 mov ecx,[ebp+08] ...[0000134b][00102236][00001341] 51 push ecx ...[0000134c][00102232][00001351] e840feffff call 00001191

Begin Local Halt Decider Simulation Execution Trace Stored at:2122fe ...[00001341][002122ea][002122ee] 55 push ebp ...[00001342][002122ea][002122ee] 8bec mov ebp,esp ...[00001344][002122ea][002122ee] 8b4508 mov eax,[ebp+08] ...[00001347][002122e6][00001341] 50 push eax ...[00001348][002122e6][00001341] 8b4d08 mov ecx,[ebp+08] ...[0000134b][002122e2][00001341] 51 push ecx ...[0000134c][002122de][00001351] e840feffff call 00001191

...[00001341][0025cd12][0025cd16] 55 push ebp ...[00001342][0025cd12][0025cd16] 8bec mov ebp,esp ...[00001344][0025cd12][0025cd16] 8b4508 mov eax,[ebp+08] ...[00001347][0025cd0e][00001341] 50 push eax ...[00001348][0025cd0e][00001341] 8b4d08 mov ecx,[ebp+08] ...[0000134b][0025cd0a][00001341] 51 push ecx ...[0000134c][0025cd06][00001351] e840feffff call 00001191
Local Halt Decider: Infinite Recursion Detected Simulation Stopped ...[00001351][0010223e][0010224a] 83c408 add esp,+08 ...[00001354][0010223e][0010224a] 85c0 test eax,eax ...[00001356][0010223e][0010224a] 7402 jz 0000135a ...[0000135a][00102242][0000136e] 5d pop ebp ...[0000135b][00102246][00001341] c3 ret ...[0000136e][0010224a][00000000] 83c404 add esp,+04 ...[00001371][0010224a][00000000] 33c0 xor eax,eax ...[00001373][0010224e][00100000] 5d pop ebp ...[00001374][00102252][00000000] c3 ret
Number of Instructions Executed(15900)

--
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, sci.math

On 5/30/22 6:57 PM, olcott wrote:

On 5/30/2022 2:17 PM, André G. Isaak wrote:

On 2022-05-30 11:59, olcott wrote:

On 5/30/2022 11:56 AM, André G. Isaak wrote:

A *correct* emulation of P(P) would emulate the exact same sequence
of instructions that occurs when you run P(P) directly,

This is factually incorrect.

How exactly? How would *you* define "correct emulation" if not as
above? You can propose whatever definition you want, but unless the
rest of the world accepts your definition you're not going to get
anywhere.

The first seven instructions are the same.
The next instructions are not the same.

Yes. They diverge. That's what it MEANS to be an INcorrect emulation.

The x86 source-code of P proves that they must diverge.
When the executed P(P) calls H(P,P) it must return to P.

Right.

When the simulated input to H(P,P) calls H(P,P) it cannot return to P
because it keeps simulating the same first seven instructions of P until aborted.

No, that presumes that the simulated H won't ever abort.

A CORRECT simulation of that input would see that H that P calls perform
its simulation, then the simulated H deciding to abort its simulaton,
and returning to P, just like the directly executed version did.

You error is presuming that H CAN correctly simulate this input and give
an answer.

If you assume an impossibility, you can get wrong answers, you need to
double check that you assumptions actually are possible.

The fact you fail to do this shows that you are a gross amateur at doing
logic. You Arguemnt begins with a false premis, that H can do a correct simulation of its input and answer.ca

This would be clear to everyone with sufficient technical competence.
This would be clear to everyone with sufficient technical competence.
This would be clear to everyone with sufficient technical competence.
This would be clear to everyone with sufficient technical competence.
This would be clear to everyone with sufficient technical competence.

No, it shows you are not technicall competent.

All it shows is that H can not correct simulate this input and deliver
ans answer at the same time.

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

int main()
{
  P(P);
}

_P()
[00001341](01)  55              push ebp
[00001342](02)  8bec            mov ebp,esp
[00001344](03)  8b4508          mov eax,[ebp+08]
[00001347](01)  50              push eax
[00001348](03)  8b4d08          mov ecx,[ebp+08]
[0000134b](01)  51              push ecx
[0000134c](05)  e840feffff      call 00001191
[00001351](03)  83c408          add esp,+08
[00001354](02)  85c0            test eax,eax
[00001356](02)  7402            jz 0000135a
[00001358](02)  ebfe            jmp 00001358
[0000135a](01)  5d              pop ebp
[0000135b](01)  c3              ret
Size in bytes:(0027) [0000135b]

_main()
[00001361](01)  55              push ebp
[00001362](02)  8bec            mov ebp,esp
[00001364](05)  6841130000      push 00001341
[00001369](05)  e8d3ffffff      call 00001341
[0000136e](03)  83c404          add esp,+04
[00001371](02)  33c0            xor eax,eax
[00001373](01)  5d              pop ebp
[00001374](01)  c3              ret
Size in bytes:(0020) [00001374]

 machine   stack     stack     machine    assembly
 address   address   data      code       language
 ========  ========  ========  =========  ============= ...[00001361][0010224a][00000000] 55              push ebp ...[00001362][0010224a][00000000] 8bec            mov ebp,esp ...[00001364][00102246][00001341] 6841130000      push 00001341 ...[00001369][00102242][0000136e] e8d3ffffff      call 00001341 ...[00001341][0010223e][0010224a] 55              push ebp ...[00001342][0010223e][0010224a] 8bec            mov ebp,esp ...[00001344][0010223e][0010224a] 8b4508          mov eax,[ebp+08] ...[00001347][0010223a][00001341] 50              push eax ...[00001348][0010223a][00001341] 8b4d08          mov ecx,[ebp+08] ...[0000134b][00102236][00001341] 51              push ecx ...[0000134c][00102232][00001351] e840feffff      call 00001191

Begin Local Halt Decider Simulation   Execution Trace Stored at:2122fe ...[00001341][002122ea][002122ee] 55              push ebp ...[00001342][002122ea][002122ee] 8bec            mov ebp,esp ...[00001344][002122ea][002122ee] 8b4508          mov eax,[ebp+08] ...[00001347][002122e6][00001341] 50              push eax ...[00001348][002122e6][00001341] 8b4d08          mov ecx,[ebp+08] ...[0000134b][002122e2][00001341] 51              push ecx ...[0000134c][002122de][00001351] e840feffff      call 00001191

And here is where the simulation goes wrong. After the call to 00001191,
the next instruction simulated needs to be the instruction at 00001191

...[00001341][0025cd12][0025cd16] 55              push ebp ...[00001342][0025cd12][0025cd16] 8bec            mov ebp,esp ...[00001344][0025cd12][0025cd16] 8b4508          mov eax,[ebp+08] ...[00001347][0025cd0e][00001341] 50              push eax ...[00001348][0025cd0e][00001341] 8b4d08          mov ecx,[ebp+08] ...[0000134b][0025cd0a][00001341] 51              push ecx ...[0000134c][0025cd06][00001351] e840feffff      call 00001191
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

And H just made an invalid conclusion because it did not use valid
inference rules, thus it got the wrong answer.

...[00001351][0010223e][0010224a] 83c408          add esp,+08 ...[00001354][0010223e][0010224a] 85c0            test eax,eax ...[00001356][0010223e][0010224a] 7402            jz 0000135a ...[0000135a][00102242][0000136e] 5d              pop ebp ...[0000135b][00102246][00001341] c3              ret

And here we see that the correct simulation shows that P(P) halts, and
thus the CORRECT simulation of the input to H(P,P) will halt, since the DEFINTION of the correct simulation IS what P(P) does.

...[0000136e][0010224a][00000000] 83c404          add esp,+04 ...[00001371][0010224a][00000000] 33c0            xor eax,eax ...[00001373][0010224e][00100000] 5d              pop ebp ...[00001374][00102252][00000000] c3              ret
Number of Instructions Executed(15900)

Thus, this above trae PROVES that P(P) Halts, and thus the correct
simulation of the input to H(P,P) Halts, and that H doesn't do a
"Correct Simulation" (at least by the rules of the Halting Problem) so
it got the wrohg answer.

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