XPost: comp.theory, sci.logic

olcott <NoOne@NoWhere.com> writes:

On 5/20/2022 6:25 AM, Ben wrote:

olcott <NoOne@NoWhere.com> writes:

On 5/19/2022 7:53 PM, Ben wrote:

olcott <NoOne@NoWhere.com> writes:

ONE CAN VERIFY THAT THE EXECUTION TRACE IS CORRECT ON THE BASIS THAT >>>>> THE EXECUTION TRACE OF THE INPUT TO H(P,P) CORRESPONDS TO
THE BEHAVIOR SPECIFIED BY THE X86 SOURCE-CODE OF P
WHERE H(P,P) CORRECTLY EMULATES ITS INPUT
THAT CALLS H(P,P) THAT CORRECTLY EMULATES ITS INPUT

Rather than shouting, you could either publish an honest, un-edited
execution trace,

If you can't understand that a single page already proves that
H(p,P)==0 is correct it is certainly the case that providing 237-fold
more details [would not help].

(Your correction added)

Your traces are edited. No one will believe them until you post the
real trace, and even then you will have some work to do to convince
people you are being honest about the output.

I can simply upgrade to smarter people that don't lie.

I don't lie. Your trace does not show what you claim H is doing. And
having admitted to editing the traces, no one is going to believe you.

But I urge you, most forcefully, to find someone to review your claims
who you have enough respect for to listen to what they have to say.

These smart non-liars would know that they don't need the 237 pages of execution trace or the source-code of H to definitively determine that H(P,P)==0 is correct.

It would be dumb to accept edited traces that don't show the nested
emulation you claim is occurring. Maybe you can find a smart sucker out
there? We all know they exist.

But first you'd have explain why they should care about what H is
actually deciding since it isn't the halting of the call specified by
the problem definition. Apparently you accept (but dare not actually
state) that not algorithm an do what H is supposed to do. It'll be hard
to get people enthusiastic about a function that just gets halting of
the conventional constriction wrong.

Number of Instructions Executed(15892) = 237 pages

Post it all (if indeed it even exists) or better yet, stop keeping H a
secret.

--
Ben.
"le génie humain a des limites, quand la bêtise humaine n’en a pas" Alexandre Dumas (fils)

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

XPost: comp.theory, sci.logic

On 5/20/2022 6:25 AM, Ben wrote:

olcott <NoOne@NoWhere.com> writes:

On 5/19/2022 7:53 PM, Ben wrote:

olcott <NoOne@NoWhere.com> writes:

ONE CAN VERIFY THAT THE EXECUTION TRACE IS CORRECT ON THE BASIS THAT
THE EXECUTION TRACE OF THE INPUT TO H(P,P) CORRESPONDS TO
THE BEHAVIOR SPECIFIED BY THE X86 SOURCE-CODE OF P
WHERE H(P,P) CORRECTLY EMULATES ITS INPUT
THAT CALLS H(P,P) THAT CORRECTLY EMULATES ITS INPUT

Rather than shouting, you could either publish an honest, un-edited
execution trace,

If you can't understand that a single page already proves that
H(p,P)==0 is correct it is certainly the case that providing 237-fold
more details [would not help].

(Your correction added)

Yours traces are edited. No one will believe them until you post the
real trace, and even then you will have some work to do to convince
people you are being honest about the output.

I can simply upgrade to smarter people that don't lie.

They would be able to confirm that the execution trace of the first 7 instructions of the input to H(P,P) is the execution trace of P.
Malcolm already did that.

When I tell them that H only performs a pure simulation of its input
then these smart non-liars would be able to confirm that the next 7
lines of the execution trace of P are the correct 7 lines for this
nested simulation of P.

These smart non-liars would know that they don't need the 237 pages of execution trace or the source-code of H to definitively determine that H(P,P)==0 is correct. They would be able to see the P does specify
infinitely nested simulation that never reaches its own final state at
machine address: [0000136c].


#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) = 237 pages

Anyway, it's no skin off my nose. H fails at the task you once set
yourself -- the one the word cares about -- so finding out what H is
actually deciding is just an amusing distraction.

--
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/20/22 10:51 AM, olcott wrote:

On 5/20/2022 6:25 AM, Ben wrote:

olcott <NoOne@NoWhere.com> writes:

On 5/19/2022 7:53 PM, Ben wrote:

olcott <NoOne@NoWhere.com> writes:

ONE CAN VERIFY THAT THE EXECUTION TRACE IS CORRECT ON THE BASIS THAT >>>>> THE EXECUTION TRACE OF THE INPUT TO H(P,P) CORRESPONDS TO
THE BEHAVIOR SPECIFIED BY THE X86 SOURCE-CODE OF P
WHERE H(P,P) CORRECTLY EMULATES ITS INPUT
THAT CALLS H(P,P) THAT CORRECTLY EMULATES ITS INPUT

Rather than shouting, you could either publish an honest, un-edited
execution trace,

If you can't understand that a single page already proves that
H(p,P)==0 is correct it is certainly the case that providing 237-fold
more details [would not help].

(Your correction added)

Yours traces are edited.  No one will believe them until you post the
real trace, and even then you will have some work to do to convince
people you are being honest about the output.

I can simply upgrade to smarter people that don't lie.

You mean replace yourself?

The other people are not lying, you are.

They would be able to confirm that the execution trace of the first 7 instructions of the input to H(P,P) is the execution trace of P.
Malcolm already did that.

When I tell them that H only performs a pure simulation of its input
then these smart non-liars would be able to confirm that the next 7
lines of the execution trace of P are the correct 7 lines for this
nested simulation of P.

LIE. H does NOT do a "Pure Simulation" by the meaning of the words,
since it can abort its simulation.

There is no such thing as Conditional Unconditional processing.

The is no actual execution of P inside the simulation done by the H
called by P, so reporting that is just a LIE.

These smart non-liars would know that they don't need the 237 pages of execution trace or the source-code of H to definitively determine that H(P,P)==0 is correct. They would be able to see the P does specify
infinitely nested simulation that never reaches its own final state at machine address: [0000136c].

No, we just need to simple examination of the code to see that H(P,P)
must be wrong to say P(P) is non-halting when it returns 0.

If it isn't answering about P(P), then YOU are LYING that H is a Halting Decider.

#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

BEGIN THE BIG LIE.

...[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) = 237 pages

Anyway, it's no skin off my nose.  H fails at the task you once set
yourself -- the one the word cares about -- so finding out what H is
actually deciding is just an amusing distraction.

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