Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  nodelist  faq  login

When we write programs that "learn", it turns out we do and they don't.


computers / comp.ai.philosophy / Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs

SubjectAuthor
* H(P,P)==0 is proven to be correct thus refuting the halting problemolcott
`* Re: H(P,P)==0 is proven to be correct thus refuting the haltingRichard Damon
 `* Re: H(P,P)==0 is proven to be correct thus refuting the haltingolcott
  `* Re: H(P,P)==0 is proven to be correct thus refuting the haltingRichard Damon
   `* Re: H(P,P)==0 is proven to be correct thus refuting the haltingolcott
    `* Re: H(P,P)==0 is proven to be correct thus refuting the haltingRichard Damon
     `* Re: H(P,P)==0 is proven to be correct thus refuting the haltingolcott
      +- Re: H(P,P)==0 is proven to be correct thus refuting the haltingolcott
      `* Re: H(P,P)==0 is proven to be correct thus refuting the halting problem prRichard Damon
       `* Re: H(P,P)==0 is proven to be correct thus refuting the haltingolcott
        `* Re: H(P,P)==0 is proven to be correct thus refuting the halting problem prRichard Damon
         `* Re: H(P,P)==0 is proven to be correct thus refuting the haltingolcott
          `* Re: H(P,P)==0 is proven to be correct thus refuting the haltingRichard Damon
           `* Re: H(P,P)==0 is proven to be correct thus refuting the haltingolcott
            `* Re: H(P,P)==0 is proven to be correct thus refuting the haltingRichard Damon
             `* Re: H(P,P)==0 is proven to be correct thus refuting the haltingolcott
              `* Re: H(P,P)==0 is proven to be correct thus refuting the haltingRichard Damon
               `* Re: H(P,P)==0 is proven to be correct thus refuting the haltingolcott
                `* Re: H(P,P)==0 is proven to be correct thus refuting the haltingRichard Damon
                 `* Re: H(P,P)==0 is proven to be correct thus refuting the haltingolcott
                  `- Re: H(P,P)==0 is proven to be correct thus refuting the haltingRichard Damon

1
Subject: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.lang.c, comp.lang.c++
Date: Sat, 21 May 2022 14:44 UTC
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 09:44:09 -0500
Date: Sat, 21 May 2022 09:44:08 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Newsgroups: comp.theory,comp.ai.philosophy,comp.lang.c,comp.lang.c++
Content-Language: en-US
From: NoO...@NoWhere.com (olcott)
Subject: H(P,P)==0 is proven to be correct thus refuting the halting problem
proofs
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <2o6dnUiVkpwkZxX_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 138
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Po6LF6CffbuT0hDLRCNUE5qH8eFW3fTfVesV8LKxT3MUmoK5nDbR+5+YqPBXYjvJGKfnNiawk9foySH!1K/WsOKZtVsiAdIsMz7ynjeh5V7hVwXjiJAJBul8drQRku04CCHWAA/wWbA4jgW4EbVLU6rx3pk=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 7157
View all headers
It is an easily verified fact that the execution trace provided by H(P,P) of the nested simulation of its input exactly matches the behavior of the correctly reverse-engineered nested execution trace would be.

To reverse-engineer this execution trace we only need to step through the x86 source-code of P and simply hypothesize that H does perform a pure x86 emulation of its input.

If H did correctly perform a pure x86 emulation of P then these first instructions of P would be executed in sequence.

_P()
[00001352](01)  55              push ebp
[00001353](02)  8bec            mov ebp,esp
[00001355](03)  8b4508          mov eax,[ebp+08]
[00001358](01)  50              push eax      // push P
[00001359](03)  8b4d08          mov ecx,[ebp+08]
[0000135c](01)  51              push ecx      // push P
[0000135d](05)  e840feffff      call 000011a2 // call H

The last line of code calls H(P,P) that would of course have to emulate these same seven instructions again. From this we can see that P would never reach its own final state at [0000136c]. When "halting" is defined as reaching a final state we correctly conclude that P is non-halting.

This shows that H(P,P) does match the halting problem proof
counter-example pattern. Instead of source-code that must be
interpreted or compiled the machine language of P is passed to H.

    For any program H that might determine if programs
    halt, a "pathological" program P, called with some
    input, can pass its own source and its input to H
    and then specifically do the opposite of what H
    predicts P will do. No H can exist that handles this
    case. https://en.wikipedia.org/wiki/Halting_problem

#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      // push P
[00001359](03)  8b4d08          mov ecx,[ebp+08]
[0000135c](01)  51              push ecx      // push P
[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

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


Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs
From: Richard Damon
Newsgroups: comp.theory, comp.ai.philosophy, comp.lang.c, comp.lang.c++
Organization: Forte - www.forteinc.com
Date: Sat, 21 May 2022 15:14 UTC
References: 1
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx96.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.9.0
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting
problem proofs
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,comp.lang.c,comp.lang.c++
References: <2o6dnUiVkpwkZxX_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <2o6dnUiVkpwkZxX_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 186
Message-ID: <2l7iK.4210$3Gzd.996@fx96.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 21 May 2022 11:14:06 -0400
X-Received-Bytes: 9354
View all headers

On 5/21/22 10:44 AM, olcott wrote:
It is an easily verified fact that the execution trace provided by H(P,P) of the nested simulation of its input exactly matches the behavior of the correctly reverse-engineered nested execution trace would be.

No, it is easy to verify that it does NOT.

No execution path from P actually CALLS another copy of P, as your trace implies.

Remember, an execution trace is supposed to show the sequence of instructions that a CPU would actually execute if we ran the program.

Since H is defined to SIMULATE its input, it isn't actually executed, so to trace it like it was is just INCORRECT.


To reverse-engineer this execution trace we only need to step through the x86 source-code of P and simply hypothesize that H does perform a pure x86 emulation of its input.


Right, so why don't we see that emulation? H doesn't CALL P, it emulates it, so reporting as if that was just being executed is just a LIE.

If H did correctly perform a pure x86 emulation of P then these first instructions of P would be executed in sequence.

_P()
[00001352](01)  55              push ebp
[00001353](02)  8bec            mov ebp,esp
[00001355](03)  8b4508          mov eax,[ebp+08]
[00001358](01)  50              push eax      // push P
[00001359](03)  8b4d08          mov ecx,[ebp+08]
[0000135c](01)  51              push ecx      // push P
[0000135d](05)  e840feffff      call 000011a2 // call H

The last line of code calls H(P,P) that would of course have to emulate these same seven instructions again. From this we can see that P would never reach its own final state at [0000136c]. When "halting" is defined as reaching a final state we correctly conclude that P is non-halting.

Right, so we should see the EMULATION of those instructions.

Note, we know that H isn't doing an UNCONDITIONAL emulation of those instructions, as you have stated that H will abort its simulation of its input when it detects what it thinks is infinite behavior, so we KNOW that if we looked at a CORRECT UNCOONDITIONAL simulation of P, we would see that happen, return the non-halting value to P and P then Halting.

That PROVES that the simulation of P by H is NOT a correct simulation with a correct decision to abort.

The problem is that P's logic is ignoring the conditionals in the embedded copy of H, meaning it is using INVALID logic.



This shows that H(P,P) does match the halting problem proof
counter-example pattern. Instead of source-code that must be
interpreted or compiled the machine language of P is passed to H.

Nope.


    For any program H that might determine if programs
    halt, a "pathological" program P, called with some
    input, can pass its own source and its input to H
    and then specifically do the opposite of what H
    predicts P will do. No H can exist that handles this
    case. https://en.wikipedia.org/wiki/Halting_problem


And since P(P) Halts, and your H(P,P) says it doesn't, your H gives the wrong answer, so it is NOT a counter example for that statement.

Please show you can read the requirements.

H given the code for P, did NOT correctly determine what P(P) would do.

Thus if FAILED.


#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      // push P
[00001359](03)  8b4d08          mov ecx,[ebp+08]
[0000135c](01)  51              push ecx      // push P
[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

Note, trace is incorrect after this point.

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

Halting problem undecidability and infinitely nested simulation (V5)

https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5

But P(P)  will Halt, so the answer is WRONG.


Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.lang.c, comp.lang.c++
Date: Sat, 21 May 2022 15:47 UTC
References: 1 2
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 10:47:17 -0500
Date: Sat, 21 May 2022 10:47:16 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting
problem proofs
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,comp.lang.c,comp.lang.c++
References: <2o6dnUiVkpwkZxX_nZ2dnUU7_83NnZ2d@giganews.com>
<2l7iK.4210$3Gzd.996@fx96.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <2l7iK.4210$3Gzd.996@fx96.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <pbWdnQ8FgdkYlBT_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 37
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-sjEIZFz8UqhHB2aqcOtwzIRcNIGWr5jGLmuc6BPHKmBkkOLlUBA5W1yMmDyXV9aoUyhlJu6DsiD/d0q!/ETh8JZ4ZNYeZnqMKSESd6zVJp6P9MwZhJM7o8uVnYy+NN0AOY7ulLwuJ32jCGoi0YNOSgc1nj4=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 2759
View all headers
On 5/21/2022 10:14 AM, Richard Damon wrote:

On 5/21/22 10:44 AM, olcott wrote:
It is an easily verified fact that the execution trace provided by H(P,P) of the nested simulation of its input exactly matches the behavior of the correctly reverse-engineered nested execution trace would be.

No, it is easy to verify that it does NOT.
You know that you are a liar so I challenge you to provide the execution trace that a pure single level nested emulation of the input to H(P,P) would be. Any failure to provide this basis for your damned lies will be considered direct admission that you know you are lying.

_P()
[00001352](01)  55              push ebp
[00001353](02)  8bec            mov ebp,esp
[00001355](03)  8b4508          mov eax,[ebp+08]
[00001358](01)  50              push eax      // push P
[00001359](03)  8b4d08          mov ecx,[ebp+08]
[0000135c](01)  51              push ecx      // push P
[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]


--
Copyright 2022 Pete Olcott

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


Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs
From: Richard Damon
Newsgroups: comp.theory, comp.ai.philosophy, comp.lang.c, comp.lang.c++
Organization: Forte - www.forteinc.com
Date: Sat, 21 May 2022 16:22 UTC
References: 1 2 3
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx36.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.9.0
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting
problem proofs
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,comp.lang.c,comp.lang.c++
References: <2o6dnUiVkpwkZxX_nZ2dnUU7_83NnZ2d@giganews.com>
<2l7iK.4210$3Gzd.996@fx96.iad>
<pbWdnQ8FgdkYlBT_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <pbWdnQ8FgdkYlBT_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 166
Message-ID: <Rk8iK.97$oBkb.52@fx36.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 21 May 2022 12:22:09 -0400
X-Received-Bytes: 8763
View all headers
On 5/21/22 11:47 AM, olcott wrote:
On 5/21/2022 10:14 AM, Richard Damon wrote:

On 5/21/22 10:44 AM, olcott wrote:
It is an easily verified fact that the execution trace provided by H(P,P) of the nested simulation of its input exactly matches the behavior of the correctly reverse-engineered nested execution trace would be.

No, it is easy to verify that it does NOT.
You know that you are a liar so I challenge you to provide the execution trace that a pure single level nested emulation of the input to H(P,P) would be. Any failure to provide this basis for your damned lies will be considered direct admission that you know you are lying.

_P()
[00001352](01)  55              push ebp
[00001353](02)  8bec            mov ebp,esp
[00001355](03)  8b4508          mov eax,[ebp+08]
[00001358](01)  50              push eax      // push P
[00001359](03)  8b4d08          mov ecx,[ebp+08]
[0000135c](01)  51              push ecx      // push P
[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]




Well, I wopuld need to have the code for H to do that, since that is PART of P.

It would begin as:

     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  =============
....[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

At this point I don't have the data, but it would trace the instructions that H executes as it simulates its copy of P until it reaches the point it decides to abort its simulation and return to P

Then it would continue to:

....[00001362][00212332][00001362] 83c408     add esp,+08
....[00001365][0021233a][00001352] 85c0       test eax,eax
....[00001367][0021233a][00001352] 7402       jz 0000136b
....[0000136b][0021233a][00001352] 5d         pop ebp
....[0000136c][0021233a][00001352] c3         ret

And P thus Halts.

(Disclaimer, Hand done so typeographical errors may exist)

YOU even have provided the basis of this trace when you published this equivalent a while back (The trace of H_Hat(H_Hat)

This had the issue that it traces the simulated program that the simulated H was simulating rather than H itself, but the rest shows what happens.

 > void H_Hat(u32 P)
 > {
 >  u32 Input_Halts = Halts(P, P);
 >  if (Input_Halts)
 >    HERE: goto HERE;
 > }
 >
 >
 > int main()
 > {
 >  H_Hat((u32)H_Hat);
 > }
 >
 >
 > _H_Hat()
 > [00000b98](01)  55                  push ebp
 > [00000b99](02)  8bec                mov ebp,esp
 >
[00000b9b](01)  51                  push ecx
 > [00000b9c](03)  8b4508              mov eax,[ebp+08]
 > [00000b9f](01)  50                  push eax
 > [00000ba0](03)  8b4d08              mov ecx,[ebp+08]
 > [00000ba3](01)  51                  push ecx
 > [00000ba4](05)  e88ffdffff          call 00000938
 > [00000ba9](03)  83c408              add esp,+08
 > [00000bac](03)  8945fc              mov [ebp-04],eax
 > [00000baf](04)  837dfc00            cmp dword [ebp-04],+00
 > [00000bb3](02)  7402                jz 00000bb7
 > [00000bb5](02)  ebfe                jmp 00000bb5
 > [00000bb7](02)  8be5                mov esp,ebp
 > [00000bb9](01)  5d                  pop ebp
 > [00000bba](01)  c3                  ret
 > Size in bytes:(0035) [00000bba]
 >
 > _main()
 > [00000bc8](01)  55                  push ebp
 > [00000bc9](02)  8bec                mov ebp,esp
 > [00000bcb](05)  68980b0000          push 00000b98
 > [00000bd0](05)  e8c3ffffff          call 00000b98
 > [00000bd5](03)  83c404              add esp,+04
 > [00000bd8](02)  33c0                xor eax,eax
 > [00000bda](01)  5d                  pop ebp
 > [00000bdb](01)  c3                  ret
 > Size in bytes:(0020) [00000bdb]
 >
 > ===============================
 > ...[00000bc8][001015d4][00000000](01)  55         push ebp
 > ...[00000bc9][001015d4][00000000](02)  8bec       mov ebp,esp
 > ...[00000bcb][001015d0][00000b98](05)  68980b0000 push 00000b98
 > ...[00000bd0][001015cc][00000bd5](05)  e8c3ffffff call 00000b98
 > ...[00000b98][001015c8][001015d4](01)  55         push ebp
 > ...[00000b99][001015c8][001015d4](02)  8bec       mov ebp,esp
 > ...[00000b9b][001015c4][00000000](01)  51         push ecx
 > ...[00000b9c][001015c4][00000000](03)  8b4508     mov  eax,[ebp+08]
 > ...[00000b9f][001015c0][00000b98](01)  50         push eax
 > ...[00000ba0][001015c0][00000b98](03)  8b4d08     mov ecx,[ebp+08]
 > ...[00000ba3][001015bc][00000b98](01)  51         push ecx
 > ...[00000ba4][001015b8][00000ba9](05)  e88ffdffff call 00000938
 > Begin Local Halt Decider Simulation at Machine Address:b98
 > ...[00000b98][00211674][00211678](01)  55         push ebp
 > ...[00000b99][00211674][00211678](02)  8bec       mov ebp,esp
 > ...[00000b9b][00211670][00201644](01)  51         push ecx
 > ...[00000b9c][00211670][00201644](03)  8b4508     mov eax,[ebp+08]
 > ...[00000b9f][0021166c][00000b98](01)  50         push eax
 > ...[00000ba0][0021166c][00000b98](03)  8b4d08     mov ecx,[ebp+08]
 > ...[00000ba3][00211668][00000b98](01)  51         push ecx
 > ...[00000ba4][00211664][00000ba9](05)  e88ffdffff call 00000938
 > ...[00000b98][0025c09c][0025c0a0](01)  55         push ebp
 > ...[00000b99][0025c09c][0025c0a0](02)  8bec       mov ebp,esp
 > ...[00000b9b][0025c098][0024c06c](01)  51         push ecx
 > ...[00000b9c][0025c098][0024c06c](03)  8b4508     mov eax,[ebp+08]
 > ...[00000b9f][0025c094][00000b98](01)  50         push eax
 > ...[00000ba0][0025c094][00000b98](03)  8b4d08     mov ecx,[ebp+08]
 > ...[00000ba3][0025c090][00000b98](01)  51         push ecx
 > ...[00000ba4][0025c08c][00000ba9](05)  e88ffdffff call 00000938
 > Local Halt Decider: Infinite Recursion Detected Simulation Stopped

Above decision was from the call the Halts inside H_Hat, deciding that H_Hat(H_Hat) seems to be non-halting, it then returns that answer and is processed below:

 > ...[00000ba9][001015c4][00000000](03)  83c408     add esp,+08
 > ...[00000bac][001015c4][00000000](03)  8945fc     mov [ebp-04],eax

Click here to read the complete article
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.lang.c, comp.lang.c++
Date: Sat, 21 May 2022 16:28 UTC
References: 1 2 3 4
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 11:28:21 -0500
Date: Sat, 21 May 2022 11:28:20 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting
problem proofs
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,comp.lang.c,comp.lang.c++
References: <2o6dnUiVkpwkZxX_nZ2dnUU7_83NnZ2d@giganews.com>
<2l7iK.4210$3Gzd.996@fx96.iad>
<pbWdnQ8FgdkYlBT_nZ2dnUU7_83NnZ2d@giganews.com> <Rk8iK.97$oBkb.52@fx36.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <Rk8iK.97$oBkb.52@fx36.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <Gr2dnQUB1by4jhT_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 65
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-SaPI4coixHRiODGARVxKLglf/NY33Tj/FLzVoXInPAbwqEisQKlsJGBJt75tMKzCdd5SNbuHNonB2Zo!RP1+Yo2B3RVUTomvv4hazVldS9r5PIMAhEfY3RPLBgvhSgoa9H+EDIWmNAcqTVRfo8E9TCemFJg=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 4344
View all headers
On 5/21/2022 11:22 AM, Richard Damon wrote:
On 5/21/22 11:47 AM, olcott wrote:
On 5/21/2022 10:14 AM, Richard Damon wrote:

On 5/21/22 10:44 AM, olcott wrote:
It is an easily verified fact that the execution trace provided by H(P,P) of the nested simulation of its input exactly matches the behavior of the correctly reverse-engineered nested execution trace would be.

No, it is easy to verify that it does NOT.
You know that you are a liar so I challenge you to provide the execution trace that a pure single level nested emulation of the input to H(P,P) would be. Any failure to provide this basis for your damned lies will be considered direct admission that you know you are lying.

_P()
[00001352](01)  55              push ebp
[00001353](02)  8bec            mov ebp,esp
[00001355](03)  8b4508          mov eax,[ebp+08]
[00001358](01)  50              push eax      // push P
[00001359](03)  8b4d08          mov ecx,[ebp+08]
[0000135c](01)  51              push ecx      // push P
[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]




Well, I wopuld need to have the code for H to do that, since that is PART of P.

It would begin as:

     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  =============
...[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

At this point I don't have the data,

The assumption is that H(P,P) correctly emulates its input.
You are required to show the execution trace of the input to H(P,P) under that assumption for one emulation and one nested emulation.
The one that you provided for the emulation is correct.


--
Copyright 2022 Pete Olcott

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


Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs
From: Richard Damon
Newsgroups: comp.theory, comp.ai.philosophy
Organization: Forte - www.forteinc.com
Date: Sat, 21 May 2022 16:38 UTC
References: 1 2 3 4 5
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx13.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.9.0
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting
problem proofs
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy
References: <2o6dnUiVkpwkZxX_nZ2dnUU7_83NnZ2d@giganews.com>
<2l7iK.4210$3Gzd.996@fx96.iad>
<pbWdnQ8FgdkYlBT_nZ2dnUU7_83NnZ2d@giganews.com> <Rk8iK.97$oBkb.52@fx36.iad>
<Gr2dnQUB1by4jhT_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <Gr2dnQUB1by4jhT_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 78
Message-ID: <5A8iK.19830$zgr9.6127@fx13.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 21 May 2022 12:38:24 -0400
X-Received-Bytes: 4445
View all headers
On 5/21/22 12:28 PM, olcott wrote:
On 5/21/2022 11:22 AM, Richard Damon wrote:
On 5/21/22 11:47 AM, olcott wrote:
On 5/21/2022 10:14 AM, Richard Damon wrote:

On 5/21/22 10:44 AM, olcott wrote:
It is an easily verified fact that the execution trace provided by H(P,P) of the nested simulation of its input exactly matches the behavior of the correctly reverse-engineered nested execution trace would be.

No, it is easy to verify that it does NOT.
You know that you are a liar so I challenge you to provide the execution trace that a pure single level nested emulation of the input to H(P,P) would be. Any failure to provide this basis for your damned lies will be considered direct admission that you know you are lying.

_P()
[00001352](01)  55              push ebp
[00001353](02)  8bec            mov ebp,esp
[00001355](03)  8b4508          mov eax,[ebp+08]
[00001358](01)  50              push eax      // push P
[00001359](03)  8b4d08          mov ecx,[ebp+08]
[0000135c](01)  51              push ecx      // push P
[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]




Well, I wopuld need to have the code for H to do that, since that is PART of P.

It would begin as:

     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  =============
...[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

At this point I don't have the data,

The assumption is that H(P,P) correctly emulates its input.

Maybe a bad assumption!

You are required to show the execution trace of the input to H(P,P) under that assumption for one emulation and one nested emulation.
The one that you provided for the emulation is correct.


WHY? That isn't the trace of *A* execution. This is mixing two different traces, which is a logical error.

Like I said, unless you give me the code for H, how can I show how it emulates its input.

You are just showing you don't know that a TRACE is supposed to show.

You also are showing you don't understand what a PROOF is.


Your requriement to me is worse than your claim of what we are asking H to do.



Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Date: Sat, 21 May 2022 16:47 UTC
References: 1 2 3 4 5 6
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 11:47:05 -0500
Date: Sat, 21 May 2022 11:47:04 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting
problem proofs
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <2o6dnUiVkpwkZxX_nZ2dnUU7_83NnZ2d@giganews.com>
<2l7iK.4210$3Gzd.996@fx96.iad>
<pbWdnQ8FgdkYlBT_nZ2dnUU7_83NnZ2d@giganews.com> <Rk8iK.97$oBkb.52@fx36.iad>
<Gr2dnQUB1by4jhT_nZ2dnUU7_8zNnZ2d@giganews.com>
<5A8iK.19830$zgr9.6127@fx13.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <5A8iK.19830$zgr9.6127@fx13.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <boKdnYDhXsgUihT_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 74
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ui3UCXzYWFhBApiqci92oOfF+EFfXYjQCMWrlZC2ICZH4fMIlx/C9xcbjizNBWAmv8cvANtXG/w6BaG!ltShZLuaEgt26wATvt0qS/VYBzNUudF2e4koityET/AmuJI50hezQ8I+aoePXEkgtIYnaRo/e9M=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 4745
View all headers
On 5/21/2022 11:38 AM, Richard Damon wrote:
On 5/21/22 12:28 PM, olcott wrote:
On 5/21/2022 11:22 AM, Richard Damon wrote:
On 5/21/22 11:47 AM, olcott wrote:
On 5/21/2022 10:14 AM, Richard Damon wrote:

On 5/21/22 10:44 AM, olcott wrote:
It is an easily verified fact that the execution trace provided by H(P,P) of the nested simulation of its input exactly matches the behavior of the correctly reverse-engineered nested execution trace would be.

No, it is easy to verify that it does NOT.
You know that you are a liar so I challenge you to provide the execution trace that a pure single level nested emulation of the input to H(P,P) would be. Any failure to provide this basis for your damned lies will be considered direct admission that you know you are lying.

_P()
[00001352](01)  55              push ebp
[00001353](02)  8bec            mov ebp,esp
[00001355](03)  8b4508          mov eax,[ebp+08]
[00001358](01)  50              push eax      // push P
[00001359](03)  8b4d08          mov ecx,[ebp+08]
[0000135c](01)  51              push ecx      // push P
[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]




Well, I wopuld need to have the code for H to do that, since that is PART of P.

It would begin as:

     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  =============
...[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

At this point I don't have the data,

The assumption is that H(P,P) correctly emulates its input.

Maybe a bad assumption!


It is stipulated that you must show what the execution trace of the input to H(P,P) would be if H only simulated its input. You must show this for one simulation and one nested simulation. Failure to do this will be construed as a direct admission that you know you are lying.



--
Copyright 2022 Pete Olcott

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


Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Date: Sat, 21 May 2022 16:56 UTC
References: 1 2 3 4 5 6 7 8
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 11:56:08 -0500
Date: Sat, 21 May 2022 11:56:07 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting
problem proofs
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <2o6dnUiVkpwkZxX_nZ2dnUU7_83NnZ2d@giganews.com>
<2l7iK.4210$3Gzd.996@fx96.iad>
<pbWdnQ8FgdkYlBT_nZ2dnUU7_83NnZ2d@giganews.com> <Rk8iK.97$oBkb.52@fx36.iad>
<Gr2dnQUB1by4jhT_nZ2dnUU7_8zNnZ2d@giganews.com>
<5A8iK.19830$zgr9.6127@fx13.iad>
<boKdnYDhXsgUihT_nZ2dnUU7_83NnZ2d@giganews.com>
<646d7b34-6937-4bc7-910a-d075c2052534n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <646d7b34-6937-4bc7-910a-d075c2052534n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <YMudnQdaxd81hBT_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 80
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-2R1c+Lhp+Te56RAHKa0DorydvFJ+JM6jAio8HY6Fm2BSmTKOoGXMTJgBfVNKPJawu+PuGc4Nxg4ijWP!HLNFsRvXhywdzPB+f9fkZSUSUgVa2kQULmUHQbeWJKtCWKBaFwdctSfqob+gGrHA0GQ1eFCfzng=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 5087
View all headers
On 5/21/2022 11:52 AM, Dennis Bush wrote:
On Saturday, May 21, 2022 at 12:47:12 PM UTC-4, olcott wrote:
On 5/21/2022 11:38 AM, Richard Damon wrote:
On 5/21/22 12:28 PM, olcott wrote:
On 5/21/2022 11:22 AM, Richard Damon wrote:
On 5/21/22 11:47 AM, olcott wrote:
On 5/21/2022 10:14 AM, Richard Damon wrote:

On 5/21/22 10:44 AM, olcott wrote:
It is an easily verified fact that the execution trace provided by
H(P,P) of the nested simulation of its input exactly matches the
behavior of the correctly reverse-engineered nested execution
trace would be.

No, it is easy to verify that it does NOT.
You know that you are a liar so I challenge you to provide the
execution trace that a pure single level nested emulation of the
input to H(P,P) would be. Any failure to provide this basis for your
damned lies will be considered direct admission that you know you
are lying.

_P()
[00001352](01)  55              push ebp
[00001353](02)  8bec            mov ebp,esp
[00001355](03)  8b4508          mov eax,[ebp+08]
[00001358](01)  50              push eax      // push P
[00001359](03)  8b4d08          mov ecx,[ebp+08]
[0000135c](01)  51              push ecx      // push P
[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]




Well, I wopuld need to have the code for H to do that, since that is
PART of P.

It would begin as:

      machine   stack     stack     machine    assembly
      address   address   data      code       language
      ========  ========  ========  =========  =============
...[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

At this point I don't have the data,

The assumption is that H(P,P) correctly emulates its input.

Maybe a bad assumption!

It is stipulated that you must show what the execution trace of the
input to H(P,P) would be if H only simulated its input.

Invalid, since H (i.e. Ha) has a fixed algorithm to abort.

H does not have a fixed algorithm to abort at any point prior to the first nested simulation, thus you are still required to show what the correct emulation of the input to H(P,P) would be for one emulation and one nested emulation. Any failure to do so will be construed as a direct admission that you know that you are lying.


--
Copyright 2022 Pete Olcott

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


Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs
From: Richard Damon
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Organization: Forte - www.forteinc.com
Date: Sat, 21 May 2022 18:58 UTC
References: 1 2 3 4 5 6 7
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!feeder.usenetexpress.com!tr3.eu1.usenetexpress.com!81.171.65.14.MISMATCH!peer02.ams4!peer.am4.highwinds-media.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx42.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0) Gecko/20100101 Thunderbird/91.9.0
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <2o6dnUiVkpwkZxX_nZ2dnUU7_83NnZ2d@giganews.com> <2l7iK.4210$3Gzd.996@fx96.iad> <pbWdnQ8FgdkYlBT_nZ2dnUU7_83NnZ2d@giganews.com> <Rk8iK.97$oBkb.52@fx36.iad> <Gr2dnQUB1by4jhT_nZ2dnUU7_8zNnZ2d@giganews.com> <5A8iK.19830$zgr9.6127@fx13.iad> <boKdnYDhXsgUihT_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <boKdnYDhXsgUihT_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 105
Message-ID: <iDaiK.48$CBlb.34@fx42.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 21 May 2022 14:58:21 -0400
X-Received-Bytes: 6003
View all headers
On 5/21/22 12:47 PM, olcott wrote:
On 5/21/2022 11:38 AM, Richard Damon wrote:
On 5/21/22 12:28 PM, olcott wrote:
On 5/21/2022 11:22 AM, Richard Damon wrote:
On 5/21/22 11:47 AM, olcott wrote:
On 5/21/2022 10:14 AM, Richard Damon wrote:

On 5/21/22 10:44 AM, olcott wrote:
It is an easily verified fact that the execution trace provided by H(P,P) of the nested simulation of its input exactly matches the behavior of the correctly reverse-engineered nested execution trace would be.

No, it is easy to verify that it does NOT.
You know that you are a liar so I challenge you to provide the execution trace that a pure single level nested emulation of the input to H(P,P) would be. Any failure to provide this basis for your damned lies will be considered direct admission that you know you are lying.

_P()
[00001352](01)  55              push ebp
[00001353](02)  8bec            mov ebp,esp
[00001355](03)  8b4508          mov eax,[ebp+08]
[00001358](01)  50              push eax      // push P
[00001359](03)  8b4d08          mov ecx,[ebp+08]
[0000135c](01)  51              push ecx      // push P
[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]




Well, I wopuld need to have the code for H to do that, since that is PART of P.

It would begin as:

     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  =============
...[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

At this point I don't have the data,

The assumption is that H(P,P) correctly emulates its input.

Maybe a bad assumption!


It is stipulated that you must show what the execution trace of the input to H(P,P) would be if H only simulated its input. You must show this for one simulation and one nested simulation. Failure to do this will be construed as a direct admission that you know you are lying.




So, give me a copy of H to trace, since THAT is what should be trace and actually should be part of the input "byte" stream, but since it is just a pointer, you can't really tell how long the input is.

The other option is right after the call to H, it needs to print:

*** ERROR: Input is not a computation, went outside its definition ***


But you said that it needs to "succeed".

What you seem to be asking for is the equivalnt of asking for a Cat that is a Dog, since the two chunks of simulation you seem to be thinking of are in DIFFERENT execution contexts, and thus aren't part of a single execution trace.

I suppose another option would be to mark EACH line of the second trace with a prefix to says SIMULTION OF, and followed by a DECIDED TO CONTINUE (reason) , or DECIDED TO ABORT (reason).


But this blows the hole in your theory as disclosing the conditional breaks the rule you are trying to apply, and make it clear that H doesn't actually have grounds to say that P is in an infinite recursion, since the rule needs no conditions that might change.


Note, I DID post a couple of messages back (16:22 GMT) a trace from YOUR system showing a trace in your format of H_Hat(H_Hat) (which you have now changed to be named P) which seems to be what you are asking for.

Yes, H can't generate such a trace, becuase an H can't be written to get the right answer.

It DOES show what the "Correct Simulation of the input to H(P,P)" would be.


Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Date: Sat, 21 May 2022 19:01 UTC
References: 1 2 3 4 5 6 7 8
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 14:01:13 -0500
Date: Sat, 21 May 2022 14:01:13 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting
problem proofs
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <2o6dnUiVkpwkZxX_nZ2dnUU7_83NnZ2d@giganews.com>
<2l7iK.4210$3Gzd.996@fx96.iad>
<pbWdnQ8FgdkYlBT_nZ2dnUU7_83NnZ2d@giganews.com> <Rk8iK.97$oBkb.52@fx36.iad>
<Gr2dnQUB1by4jhT_nZ2dnUU7_8zNnZ2d@giganews.com>
<5A8iK.19830$zgr9.6127@fx13.iad>
<boKdnYDhXsgUihT_nZ2dnUU7_83NnZ2d@giganews.com> <iDaiK.48$CBlb.34@fx42.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <iDaiK.48$CBlb.34@fx42.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <hvydnRtx-KhkqxT_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 82
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-pBiOlJduxmKKo6epnb8tCPw1dvTcvQZAJx6uoiT1cm++Pf7P1L+9GEqmatoKoyi9awWT4CAm9diUQts!BeBi20xnUbrXrY08DGpU13tGBJekLar1FGcqbNltvbD9S2EDfrnQJtLqatMfaa7QyHE9KcsU3OU=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 5296
View all headers
On 5/21/2022 1:58 PM, Richard Damon wrote:
On 5/21/22 12:47 PM, olcott wrote:
On 5/21/2022 11:38 AM, Richard Damon wrote:
On 5/21/22 12:28 PM, olcott wrote:
On 5/21/2022 11:22 AM, Richard Damon wrote:
On 5/21/22 11:47 AM, olcott wrote:
On 5/21/2022 10:14 AM, Richard Damon wrote:

On 5/21/22 10:44 AM, olcott wrote:
It is an easily verified fact that the execution trace provided by H(P,P) of the nested simulation of its input exactly matches the behavior of the correctly reverse-engineered nested execution trace would be.

No, it is easy to verify that it does NOT.
You know that you are a liar so I challenge you to provide the execution trace that a pure single level nested emulation of the input to H(P,P) would be. Any failure to provide this basis for your damned lies will be considered direct admission that you know you are lying.

_P()
[00001352](01)  55              push ebp
[00001353](02)  8bec            mov ebp,esp
[00001355](03)  8b4508          mov eax,[ebp+08]
[00001358](01)  50              push eax      // push P
[00001359](03)  8b4d08          mov ecx,[ebp+08]
[0000135c](01)  51              push ecx      // push P
[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]




Well, I wopuld need to have the code for H to do that, since that is PART of P.

It would begin as:

     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  =============
...[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

At this point I don't have the data,

The assumption is that H(P,P) correctly emulates its input.

Maybe a bad assumption!


It is stipulated that you must show what the execution trace of the input to H(P,P) would be if H only simulated its input. You must show this for one simulation and one nested simulation. Failure to do this will be construed as a direct admission that you know you are lying.




So, give me a copy of H to trace,
You are required to provide a trace under the assumption that H(P,P) only does a pure x86 emulation of its input for the first emulation and the first nested emulation. Are you too stupid to understand this?

--
Copyright 2022 Pete Olcott

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


Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs
From: Richard Damon
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Organization: Forte - www.forteinc.com
Date: Sat, 21 May 2022 19:06 UTC
References: 1 2 3 4 5 6 7 8 9
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!tr2.eu1.usenetexpress.com!feeder.usenetexpress.com!tr1.iad1.usenetexpress.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx42.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0) Gecko/20100101 Thunderbird/91.9.0
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <2o6dnUiVkpwkZxX_nZ2dnUU7_83NnZ2d@giganews.com> <2l7iK.4210$3Gzd.996@fx96.iad> <pbWdnQ8FgdkYlBT_nZ2dnUU7_83NnZ2d@giganews.com> <Rk8iK.97$oBkb.52@fx36.iad> <Gr2dnQUB1by4jhT_nZ2dnUU7_8zNnZ2d@giganews.com> <5A8iK.19830$zgr9.6127@fx13.iad> <boKdnYDhXsgUihT_nZ2dnUU7_83NnZ2d@giganews.com> <iDaiK.48$CBlb.34@fx42.iad> <hvydnRtx-KhkqxT_nZ2dnUU7_8xh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <hvydnRtx-KhkqxT_nZ2dnUU7_8xh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 88
Message-ID: <hLaiK.52$CBlb.41@fx42.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 21 May 2022 15:06:53 -0400
X-Received-Bytes: 5282
View all headers
On 5/21/22 3:01 PM, olcott wrote:
On 5/21/2022 1:58 PM, Richard Damon wrote:
On 5/21/22 12:47 PM, olcott wrote:
On 5/21/2022 11:38 AM, Richard Damon wrote:
On 5/21/22 12:28 PM, olcott wrote:
On 5/21/2022 11:22 AM, Richard Damon wrote:
On 5/21/22 11:47 AM, olcott wrote:
On 5/21/2022 10:14 AM, Richard Damon wrote:

On 5/21/22 10:44 AM, olcott wrote:
It is an easily verified fact that the execution trace provided by H(P,P) of the nested simulation of its input exactly matches the behavior of the correctly reverse-engineered nested execution trace would be.

No, it is easy to verify that it does NOT.
You know that you are a liar so I challenge you to provide the execution trace that a pure single level nested emulation of the input to H(P,P) would be. Any failure to provide this basis for your damned lies will be considered direct admission that you know you are lying.

_P()
[00001352](01)  55              push ebp
[00001353](02)  8bec            mov ebp,esp
[00001355](03)  8b4508          mov eax,[ebp+08]
[00001358](01)  50              push eax      // push P
[00001359](03)  8b4d08          mov ecx,[ebp+08]
[0000135c](01)  51              push ecx      // push P
[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]




Well, I wopuld need to have the code for H to do that, since that is PART of P.

It would begin as:

     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  =============
...[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

At this point I don't have the data,

The assumption is that H(P,P) correctly emulates its input.

Maybe a bad assumption!


It is stipulated that you must show what the execution trace of the input to H(P,P) would be if H only simulated its input. You must show this for one simulation and one nested simulation. Failure to do this will be construed as a direct admission that you know you are lying.




So, give me a copy of H to trace,
You are required to provide a trace under the assumption that H(P,P) only does a pure x86 emulation of its input for the first emulation and the first nested emulation. Are you too stupid to understand this?


You obviously have an reading problem.

I said, for that I need the code of H, as that is what needs to be traced.

To say otherwise just proves you are s stupid liar,

How else can you show an emulation of an emulator unless you have the code that is doing the emulation that needs to be shown,




Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Date: Sat, 21 May 2022 19:12 UTC
References: 1 2 3 4 5 6 7 8 9 10
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 14:12:15 -0500
Date: Sat, 21 May 2022 14:12:13 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting
problem proofs
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <2o6dnUiVkpwkZxX_nZ2dnUU7_83NnZ2d@giganews.com>
<2l7iK.4210$3Gzd.996@fx96.iad>
<pbWdnQ8FgdkYlBT_nZ2dnUU7_83NnZ2d@giganews.com> <Rk8iK.97$oBkb.52@fx36.iad>
<Gr2dnQUB1by4jhT_nZ2dnUU7_8zNnZ2d@giganews.com>
<5A8iK.19830$zgr9.6127@fx13.iad>
<boKdnYDhXsgUihT_nZ2dnUU7_83NnZ2d@giganews.com> <iDaiK.48$CBlb.34@fx42.iad>
<hvydnRtx-KhkqxT_nZ2dnUU7_8xh4p2d@giganews.com> <hLaiK.52$CBlb.41@fx42.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <hLaiK.52$CBlb.41@fx42.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <buqdnb0TML8SpBT_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 110
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ZONWWNFGbbdePm4lIoJpuGRuV0q7T4dzMeWszoeyxnkhesT8mJHLQ6f8wxhIFEi5/eoIJ3qNX/DTaLL!MKpbj7k/OJy+WWFvTvFDcFhKpYdeqQjFYxLOKjrAigwbxwv323LbXo9zIRimrn4e9olLlv1dCdY=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 6441
View all headers
On 5/21/2022 2:06 PM, Richard Damon wrote:
On 5/21/22 3:01 PM, olcott wrote:
On 5/21/2022 1:58 PM, Richard Damon wrote:
On 5/21/22 12:47 PM, olcott wrote:
On 5/21/2022 11:38 AM, Richard Damon wrote:
On 5/21/22 12:28 PM, olcott wrote:
On 5/21/2022 11:22 AM, Richard Damon wrote:
On 5/21/22 11:47 AM, olcott wrote:
On 5/21/2022 10:14 AM, Richard Damon wrote:

On 5/21/22 10:44 AM, olcott wrote:
It is an easily verified fact that the execution trace provided by H(P,P) of the nested simulation of its input exactly matches the behavior of the correctly reverse-engineered nested execution trace would be.

No, it is easy to verify that it does NOT.
You know that you are a liar so I challenge you to provide the execution trace that a pure single level nested emulation of the input to H(P,P) would be. Any failure to provide this basis for your damned lies will be considered direct admission that you know you are lying.

_P()
[00001352](01)  55              push ebp
[00001353](02)  8bec            mov ebp,esp
[00001355](03)  8b4508          mov eax,[ebp+08]
[00001358](01)  50              push eax      // push P
[00001359](03)  8b4d08          mov ecx,[ebp+08]
[0000135c](01)  51              push ecx      // push P
[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]




Well, I wopuld need to have the code for H to do that, since that is PART of P.

It would begin as:

     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  =============
...[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

At this point I don't have the data,

The assumption is that H(P,P) correctly emulates its input.

Maybe a bad assumption!


It is stipulated that you must show what the execution trace of the input to H(P,P) would be if H only simulated its input. You must show this for one simulation and one nested simulation. Failure to do this will be construed as a direct admission that you know you are lying.




So, give me a copy of H to trace,
You are required to provide a trace under the assumption that H(P,P) only does a pure x86 emulation of its input for the first emulation and the first nested emulation. Are you too stupid to understand this?


You obviously have an reading problem.

I said, for that I need the code of H, as that is what needs to be traced.


If it is "given" that this code only performs a pure x86 emulation of its input (unless you have no idea what an x86 emulation is) there is no reason to see that the code derives a pure x86 emulation of its input.

What a pure x86 emulation of the input would be can be reverse engineered entirely on the basis of the x86 source code for P.

You are not stupid for not knowing this, instead of stupid you would be technically unqualified to evaluate my work.

To say otherwise just proves you are s stupid liar,

How else can you show an emulation of an emulator unless you have the code that is doing the emulation that needs to be shown,




--
Copyright 2022 Pete Olcott

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


Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs
From: Richard Damon
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Organization: Forte - www.forteinc.com
Date: Sun, 22 May 2022 00:55 UTC
References: 1 2 3 4 5 6 7 8 9 10 11
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx45.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.9.0
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting
problem proofs
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <2o6dnUiVkpwkZxX_nZ2dnUU7_83NnZ2d@giganews.com>
<2l7iK.4210$3Gzd.996@fx96.iad>
<pbWdnQ8FgdkYlBT_nZ2dnUU7_83NnZ2d@giganews.com> <Rk8iK.97$oBkb.52@fx36.iad>
<Gr2dnQUB1by4jhT_nZ2dnUU7_8zNnZ2d@giganews.com>
<5A8iK.19830$zgr9.6127@fx13.iad>
<boKdnYDhXsgUihT_nZ2dnUU7_83NnZ2d@giganews.com> <iDaiK.48$CBlb.34@fx42.iad>
<hvydnRtx-KhkqxT_nZ2dnUU7_8xh4p2d@giganews.com> <hLaiK.52$CBlb.41@fx42.iad>
<buqdnb0TML8SpBT_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <buqdnb0TML8SpBT_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 127
Message-ID: <nSfiK.6234$IgSc.2259@fx45.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 21 May 2022 20:55:47 -0400
X-Received-Bytes: 6808
View all headers
On 5/21/22 3:12 PM, olcott wrote:
On 5/21/2022 2:06 PM, Richard Damon wrote:
On 5/21/22 3:01 PM, olcott wrote:
On 5/21/2022 1:58 PM, Richard Damon wrote:
On 5/21/22 12:47 PM, olcott wrote:
On 5/21/2022 11:38 AM, Richard Damon wrote:
On 5/21/22 12:28 PM, olcott wrote:
On 5/21/2022 11:22 AM, Richard Damon wrote:
On 5/21/22 11:47 AM, olcott wrote:
On 5/21/2022 10:14 AM, Richard Damon wrote:

On 5/21/22 10:44 AM, olcott wrote:
It is an easily verified fact that the execution trace provided by H(P,P) of the nested simulation of its input exactly matches the behavior of the correctly reverse-engineered nested execution trace would be.

No, it is easy to verify that it does NOT.
You know that you are a liar so I challenge you to provide the execution trace that a pure single level nested emulation of the input to H(P,P) would be. Any failure to provide this basis for your damned lies will be considered direct admission that you know you are lying.

_P()
[00001352](01)  55              push ebp
[00001353](02)  8bec            mov ebp,esp
[00001355](03)  8b4508          mov eax,[ebp+08]
[00001358](01)  50              push eax      // push P
[00001359](03)  8b4d08          mov ecx,[ebp+08]
[0000135c](01)  51              push ecx      // push P
[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]




Well, I wopuld need to have the code for H to do that, since that is PART of P.

It would begin as:

     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  =============
...[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

At this point I don't have the data,

The assumption is that H(P,P) correctly emulates its input.

Maybe a bad assumption!


It is stipulated that you must show what the execution trace of the input to H(P,P) would be if H only simulated its input. You must show this for one simulation and one nested simulation. Failure to do this will be construed as a direct admission that you know you are lying.




So, give me a copy of H to trace,
You are required to provide a trace under the assumption that H(P,P) only does a pure x86 emulation of its input for the first emulation and the first nested emulation. Are you too stupid to understand this?


You obviously have an reading problem.

I said, for that I need the code of H, as that is what needs to be traced.


If it is "given" that this code only performs a pure x86 emulation of its input (unless you have no idea what an x86 emulation is) there is no reason to see that the code derives a pure x86 emulation of its input.

The the trace of the emulation needs to show the actual steps of emulationg the input, like I mentioned.

If H is actually emulating the code, then the "instructions" of the second level are never actually executed, are they?

Maybe YOU don't understand what an emulator does.


What a pure x86 emulation of the input would be can be reverse engineered entirely on the basis of the x86 source code for P.

And I posted what that would be. It doesn't show a second level of direct execution, because that is just a LIE.


You are not stupid for not knowing this, instead of stupid you would be technically unqualified to evaluate my work.

Nope, you are not technically qualified to make your claims, but you make them anyway and show your ignorance.


To say otherwise just proves you are s stupid liar,

How else can you show an emulation of an emulator unless you have the code that is doing the emulation that needs to be shown,







Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Date: Sun, 22 May 2022 01:02 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 20:02:27 -0500
Date: Sat, 21 May 2022 20:02:25 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting
problem proofs
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <2o6dnUiVkpwkZxX_nZ2dnUU7_83NnZ2d@giganews.com>
<2l7iK.4210$3Gzd.996@fx96.iad>
<pbWdnQ8FgdkYlBT_nZ2dnUU7_83NnZ2d@giganews.com> <Rk8iK.97$oBkb.52@fx36.iad>
<Gr2dnQUB1by4jhT_nZ2dnUU7_8zNnZ2d@giganews.com>
<5A8iK.19830$zgr9.6127@fx13.iad>
<boKdnYDhXsgUihT_nZ2dnUU7_83NnZ2d@giganews.com> <iDaiK.48$CBlb.34@fx42.iad>
<hvydnRtx-KhkqxT_nZ2dnUU7_8xh4p2d@giganews.com> <hLaiK.52$CBlb.41@fx42.iad>
<buqdnb0TML8SpBT_nZ2dnUU7_8zNnZ2d@giganews.com>
<nSfiK.6234$IgSc.2259@fx45.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <nSfiK.6234$IgSc.2259@fx45.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <WKydnZZQmbU-FhT_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 116
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-qqB2kKlaJHT81CP7ztTYrPhD83h1ONlZoRt58KszVVIyWq8nj5+KzfHQzwBwsPX/Q0KZzPKX2QBka5O!KveK9pE68GKVeXPS9awe8Zje0jucnG5IC99BkP0oU/axOf0ywZC+kwKMuZHRBx3QA4+QpOKfokQ=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 7013
View all headers
On 5/21/2022 7:55 PM, Richard Damon wrote:
On 5/21/22 3:12 PM, olcott wrote:
On 5/21/2022 2:06 PM, Richard Damon wrote:
On 5/21/22 3:01 PM, olcott wrote:
On 5/21/2022 1:58 PM, Richard Damon wrote:
On 5/21/22 12:47 PM, olcott wrote:
On 5/21/2022 11:38 AM, Richard Damon wrote:
On 5/21/22 12:28 PM, olcott wrote:
On 5/21/2022 11:22 AM, Richard Damon wrote:
On 5/21/22 11:47 AM, olcott wrote:
On 5/21/2022 10:14 AM, Richard Damon wrote:

On 5/21/22 10:44 AM, olcott wrote:
It is an easily verified fact that the execution trace provided by H(P,P) of the nested simulation of its input exactly matches the behavior of the correctly reverse-engineered nested execution trace would be.

No, it is easy to verify that it does NOT.
You know that you are a liar so I challenge you to provide the execution trace that a pure single level nested emulation of the input to H(P,P) would be. Any failure to provide this basis for your damned lies will be considered direct admission that you know you are lying.

_P()
[00001352](01)  55              push ebp
[00001353](02)  8bec            mov ebp,esp
[00001355](03)  8b4508          mov eax,[ebp+08]
[00001358](01)  50              push eax      // push P
[00001359](03)  8b4d08          mov ecx,[ebp+08]
[0000135c](01)  51              push ecx      // push P
[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]




Well, I wopuld need to have the code for H to do that, since that is PART of P.

It would begin as:

     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  =============
...[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

At this point I don't have the data,

The assumption is that H(P,P) correctly emulates its input.

Maybe a bad assumption!


It is stipulated that you must show what the execution trace of the input to H(P,P) would be if H only simulated its input. You must show this for one simulation and one nested simulation. Failure to do this will be construed as a direct admission that you know you are lying.




So, give me a copy of H to trace,
You are required to provide a trace under the assumption that H(P,P) only does a pure x86 emulation of its input for the first emulation and the first nested emulation. Are you too stupid to understand this?


You obviously have an reading problem.

I said, for that I need the code of H, as that is what needs to be traced.


If it is "given" that this code only performs a pure x86 emulation of its input (unless you have no idea what an x86 emulation is) there is no reason to see that the code derives a pure x86 emulation of its input.

The the trace of the emulation needs to show the actual steps of emulationg the input, like I mentioned.

If I showed either the source-code of H or the execution trace of H people here would be so confused that I would never reach closure in 50 years. If they can't comprehend a 14 line execution trace then showing them much more than this would permanently scramble their brains.

The proof of technical competence to evaluating my work is understanding that I have already shown everything that it needed.

Conversely the lack of this understanding is conclusive proof of insufficient technical competence.

--
Copyright 2022 Pete Olcott

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


Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs
From: Richard Damon
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Organization: Forte - www.forteinc.com
Date: Sun, 22 May 2022 01:16 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx44.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.9.0
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting
problem proofs
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <2o6dnUiVkpwkZxX_nZ2dnUU7_83NnZ2d@giganews.com>
<2l7iK.4210$3Gzd.996@fx96.iad>
<pbWdnQ8FgdkYlBT_nZ2dnUU7_83NnZ2d@giganews.com> <Rk8iK.97$oBkb.52@fx36.iad>
<Gr2dnQUB1by4jhT_nZ2dnUU7_8zNnZ2d@giganews.com>
<5A8iK.19830$zgr9.6127@fx13.iad>
<boKdnYDhXsgUihT_nZ2dnUU7_83NnZ2d@giganews.com> <iDaiK.48$CBlb.34@fx42.iad>
<hvydnRtx-KhkqxT_nZ2dnUU7_8xh4p2d@giganews.com> <hLaiK.52$CBlb.41@fx42.iad>
<buqdnb0TML8SpBT_nZ2dnUU7_8zNnZ2d@giganews.com>
<nSfiK.6234$IgSc.2259@fx45.iad>
<WKydnZZQmbU-FhT_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <WKydnZZQmbU-FhT_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 148
Message-ID: <9agiK.1050$gjlb.537@fx44.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 21 May 2022 21:16:52 -0400
X-Received-Bytes: 8178
X-Original-Bytes: 8045
View all headers
On 5/21/22 9:02 PM, olcott wrote:
On 5/21/2022 7:55 PM, Richard Damon wrote:
On 5/21/22 3:12 PM, olcott wrote:
On 5/21/2022 2:06 PM, Richard Damon wrote:
On 5/21/22 3:01 PM, olcott wrote:
On 5/21/2022 1:58 PM, Richard Damon wrote:
On 5/21/22 12:47 PM, olcott wrote:
On 5/21/2022 11:38 AM, Richard Damon wrote:
On 5/21/22 12:28 PM, olcott wrote:
On 5/21/2022 11:22 AM, Richard Damon wrote:
On 5/21/22 11:47 AM, olcott wrote:
On 5/21/2022 10:14 AM, Richard Damon wrote:

On 5/21/22 10:44 AM, olcott wrote:
It is an easily verified fact that the execution trace provided by H(P,P) of the nested simulation of its input exactly matches the behavior of the correctly reverse-engineered nested execution trace would be.

No, it is easy to verify that it does NOT.
You know that you are a liar so I challenge you to provide the execution trace that a pure single level nested emulation of the input to H(P,P) would be. Any failure to provide this basis for your damned lies will be considered direct admission that you know you are lying.

_P()
[00001352](01)  55              push ebp
[00001353](02)  8bec            mov ebp,esp
[00001355](03)  8b4508          mov eax,[ebp+08]
[00001358](01)  50              push eax      // push P
[00001359](03)  8b4d08          mov ecx,[ebp+08]
[0000135c](01)  51              push ecx      // push P
[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]




Well, I wopuld need to have the code for H to do that, since that is PART of P.

It would begin as:

     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  =============
...[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

At this point I don't have the data,

The assumption is that H(P,P) correctly emulates its input.

Maybe a bad assumption!


It is stipulated that you must show what the execution trace of the input to H(P,P) would be if H only simulated its input. You must show this for one simulation and one nested simulation. Failure to do this will be construed as a direct admission that you know you are lying.




So, give me a copy of H to trace,
You are required to provide a trace under the assumption that H(P,P) only does a pure x86 emulation of its input for the first emulation and the first nested emulation. Are you too stupid to understand this?


You obviously have an reading problem.

I said, for that I need the code of H, as that is what needs to be traced.


If it is "given" that this code only performs a pure x86 emulation of its input (unless you have no idea what an x86 emulation is) there is no reason to see that the code derives a pure x86 emulation of its input.

The the trace of the emulation needs to show the actual steps of emulationg the input, like I mentioned.

If I showed either the source-code of H or the execution trace of H people here would be so confused that I would never reach closure in 50 years. If they can't comprehend a 14 line execution trace then showing them much more than this would permanently scramble their brains.

No, people wouldn't be confused,


The proof of technical competence to evaluating my work is understanding that I have already shown everything that it needed.

No, you are just proving that you don't know what a proof is. You post LIES of traces, that people are calling you out on.


Conversely the lack of this understanding is conclusive proof of insufficient technical competence.


Only of YOU. Someone who claims that no one can understand there work in the typical sign of someone who is deluded into thinking there false thinking it correct.

Real Genius can explain it so that most people can understand it. If you can't do that, it means you don't really understand what you are saying, since you can't break it down to component parts.

Truth can be broken down into a simple step by step explaination (it might be long). Fantasy often can't handle that level of examination as its flaws get reveiled.

Your inability to explain your idea in simpler terms means that you don't really understand the truth in it.

As you have said, if it is something that can be known, it can be expresses as an actual proof, starting from the ACCEPTED truths of the system and then combined with accepted logical operation to reach the final statement, and thus proving it.

You can't break down your idea to this step by step analysis because it is based on false premises that you can only try to justfy by keeping them too complicated.

You claims of "True by the meaning of the words", is a false claim, as you can't actually quote the meaning of the words (as accepted) to build up to the claim you want to make.


Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Date: Sun, 22 May 2022 01:25 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 20:25:26 -0500
Date: Sat, 21 May 2022 20:25:25 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting
problem proofs
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <2o6dnUiVkpwkZxX_nZ2dnUU7_83NnZ2d@giganews.com>
<2l7iK.4210$3Gzd.996@fx96.iad>
<pbWdnQ8FgdkYlBT_nZ2dnUU7_83NnZ2d@giganews.com> <Rk8iK.97$oBkb.52@fx36.iad>
<Gr2dnQUB1by4jhT_nZ2dnUU7_8zNnZ2d@giganews.com>
<5A8iK.19830$zgr9.6127@fx13.iad>
<boKdnYDhXsgUihT_nZ2dnUU7_83NnZ2d@giganews.com> <iDaiK.48$CBlb.34@fx42.iad>
<hvydnRtx-KhkqxT_nZ2dnUU7_8xh4p2d@giganews.com> <hLaiK.52$CBlb.41@fx42.iad>
<buqdnb0TML8SpBT_nZ2dnUU7_8zNnZ2d@giganews.com>
<nSfiK.6234$IgSc.2259@fx45.iad>
<WKydnZZQmbU-FhT_nZ2dnUU7_83NnZ2d@giganews.com>
<9agiK.1050$gjlb.537@fx44.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <9agiK.1050$gjlb.537@fx44.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <I6idnSPl8NebDBT_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 121
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-hCKHJlMgN0PgwoI4OY1/TnzZEiRDJ6/CaDLJHOGKcY5V17a6svirQ7yz0TT6f2nZU6w8LGlEdjQG76X!Z/bVglGGpCmOBIJn4n9p/PtxjGD45rgRZFeB9HuMXJLRG5ZIvUck/5ccKCabVaRj/xezv2lCIvk=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 7369
View all headers
On 5/21/2022 8:16 PM, Richard Damon wrote:
On 5/21/22 9:02 PM, olcott wrote:
On 5/21/2022 7:55 PM, Richard Damon wrote:
On 5/21/22 3:12 PM, olcott wrote:
On 5/21/2022 2:06 PM, Richard Damon wrote:
On 5/21/22 3:01 PM, olcott wrote:
On 5/21/2022 1:58 PM, Richard Damon wrote:
On 5/21/22 12:47 PM, olcott wrote:
On 5/21/2022 11:38 AM, Richard Damon wrote:
On 5/21/22 12:28 PM, olcott wrote:
On 5/21/2022 11:22 AM, Richard Damon wrote:
On 5/21/22 11:47 AM, olcott wrote:
On 5/21/2022 10:14 AM, Richard Damon wrote:

On 5/21/22 10:44 AM, olcott wrote:
It is an easily verified fact that the execution trace provided by H(P,P) of the nested simulation of its input exactly matches the behavior of the correctly reverse-engineered nested execution trace would be.

No, it is easy to verify that it does NOT.
You know that you are a liar so I challenge you to provide the execution trace that a pure single level nested emulation of the input to H(P,P) would be. Any failure to provide this basis for your damned lies will be considered direct admission that you know you are lying.

_P()
[00001352](01)  55              push ebp
[00001353](02)  8bec            mov ebp,esp
[00001355](03)  8b4508          mov eax,[ebp+08]
[00001358](01)  50              push eax      // push P
[00001359](03)  8b4d08          mov ecx,[ebp+08]
[0000135c](01)  51              push ecx      // push P
[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]




Well, I wopuld need to have the code for H to do that, since that is PART of P.

It would begin as:

     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  =============
...[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

At this point I don't have the data,

The assumption is that H(P,P) correctly emulates its input.

Maybe a bad assumption!


It is stipulated that you must show what the execution trace of the input to H(P,P) would be if H only simulated its input. You must show this for one simulation and one nested simulation. Failure to do this will be construed as a direct admission that you know you are lying.




So, give me a copy of H to trace,
You are required to provide a trace under the assumption that H(P,P) only does a pure x86 emulation of its input for the first emulation and the first nested emulation. Are you too stupid to understand this?


You obviously have an reading problem.

I said, for that I need the code of H, as that is what needs to be traced.


If it is "given" that this code only performs a pure x86 emulation of its input (unless you have no idea what an x86 emulation is) there is no reason to see that the code derives a pure x86 emulation of its input.

The the trace of the emulation needs to show the actual steps of emulationg the input, like I mentioned.

If I showed either the source-code of H or the execution trace of H people here would be so confused that I would never reach closure in 50 years. If they can't comprehend a 14 line execution trace then showing them much more than this would permanently scramble their brains.

No, people wouldn't be confused,


That they don't understand that they don't need to see this conclusively proves that they have woefully inadequate technical skills to evaluate my work.

--
Copyright 2022 Pete Olcott

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


Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs
From: Richard Damon
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Organization: Forte - www.forteinc.com
Date: Sun, 22 May 2022 02:27 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx11.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.9.0
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting
problem proofs
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <2o6dnUiVkpwkZxX_nZ2dnUU7_83NnZ2d@giganews.com>
<2l7iK.4210$3Gzd.996@fx96.iad>
<pbWdnQ8FgdkYlBT_nZ2dnUU7_83NnZ2d@giganews.com> <Rk8iK.97$oBkb.52@fx36.iad>
<Gr2dnQUB1by4jhT_nZ2dnUU7_8zNnZ2d@giganews.com>
<5A8iK.19830$zgr9.6127@fx13.iad>
<boKdnYDhXsgUihT_nZ2dnUU7_83NnZ2d@giganews.com> <iDaiK.48$CBlb.34@fx42.iad>
<hvydnRtx-KhkqxT_nZ2dnUU7_8xh4p2d@giganews.com> <hLaiK.52$CBlb.41@fx42.iad>
<buqdnb0TML8SpBT_nZ2dnUU7_8zNnZ2d@giganews.com>
<nSfiK.6234$IgSc.2259@fx45.iad>
<WKydnZZQmbU-FhT_nZ2dnUU7_83NnZ2d@giganews.com>
<9agiK.1050$gjlb.537@fx44.iad>
<I6idnSPl8NebDBT_nZ2dnUU7_81g4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <I6idnSPl8NebDBT_nZ2dnUU7_81g4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 144
Message-ID: <echiK.28776$J0r9.6239@fx11.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 21 May 2022 22:27:21 -0400
X-Received-Bytes: 8256
View all headers
On 5/21/22 9:25 PM, olcott wrote:
On 5/21/2022 8:16 PM, Richard Damon wrote:
On 5/21/22 9:02 PM, olcott wrote:
On 5/21/2022 7:55 PM, Richard Damon wrote:
On 5/21/22 3:12 PM, olcott wrote:
On 5/21/2022 2:06 PM, Richard Damon wrote:
On 5/21/22 3:01 PM, olcott wrote:
On 5/21/2022 1:58 PM, Richard Damon wrote:
On 5/21/22 12:47 PM, olcott wrote:
On 5/21/2022 11:38 AM, Richard Damon wrote:
On 5/21/22 12:28 PM, olcott wrote:
On 5/21/2022 11:22 AM, Richard Damon wrote:
On 5/21/22 11:47 AM, olcott wrote:
On 5/21/2022 10:14 AM, Richard Damon wrote:

On 5/21/22 10:44 AM, olcott wrote:
It is an easily verified fact that the execution trace provided by H(P,P) of the nested simulation of its input exactly matches the behavior of the correctly reverse-engineered nested execution trace would be.

No, it is easy to verify that it does NOT.
You know that you are a liar so I challenge you to provide the execution trace that a pure single level nested emulation of the input to H(P,P) would be. Any failure to provide this basis for your damned lies will be considered direct admission that you know you are lying.

_P()
[00001352](01)  55              push ebp
[00001353](02)  8bec            mov ebp,esp
[00001355](03)  8b4508          mov eax,[ebp+08]
[00001358](01)  50              push eax      // push P
[00001359](03)  8b4d08          mov ecx,[ebp+08]
[0000135c](01)  51              push ecx      // push P
[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]




Well, I wopuld need to have the code for H to do that, since that is PART of P.

It would begin as:

     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  =============
...[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

At this point I don't have the data,

The assumption is that H(P,P) correctly emulates its input.

Maybe a bad assumption!


It is stipulated that you must show what the execution trace of the input to H(P,P) would be if H only simulated its input. You must show this for one simulation and one nested simulation. Failure to do this will be construed as a direct admission that you know you are lying.




So, give me a copy of H to trace,
You are required to provide a trace under the assumption that H(P,P) only does a pure x86 emulation of its input for the first emulation and the first nested emulation. Are you too stupid to understand this?


You obviously have an reading problem.

I said, for that I need the code of H, as that is what needs to be traced.


If it is "given" that this code only performs a pure x86 emulation of its input (unless you have no idea what an x86 emulation is) there is no reason to see that the code derives a pure x86 emulation of its input.

The the trace of the emulation needs to show the actual steps of emulationg the input, like I mentioned.

If I showed either the source-code of H or the execution trace of H people here would be so confused that I would never reach closure in 50 years. If they can't comprehend a 14 line execution trace then showing them much more than this would permanently scramble their brains.

No, people wouldn't be confused,


That they don't understand that they don't need to see this conclusively proves that they have woefully inadequate technical skills to evaluate my work.


Just shows you are lying.

I think you are afraid that people DO have the technical skills to evaluate your work and if you show what you have done you will be utterly humiliated.

You have taken EXTREAMLY long times to do anything programming related to this problem, an my guess is that the code quality will show your incompetence, if you even have actual working code.

You are afraid to release to code, because then you can't keep lying about what it does. Other people could look at the enourmous trace and filter it the way THEY want to see what is actually happening and show the errors you are hidding behind your smoke and mirrors.

If people can't understand your code, then what is the harm with releasing it? It will then just remain an impenetrable black box.

You are calling people with actual credentials (which you don't have) as incompetent, while at the same time saying you need their help because you can't explain your work to write the article.

Either you are being stupid and asking people who can't help, or you are actually to stupid to know who actually know stuff.

Either way, you are proving your stupidity.


Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs [ ignorance squared ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Date: Sun, 22 May 2022 02:34 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 21:34:07 -0500
Date: Sat, 21 May 2022 21:34:06 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting
problem proofs [ ignorance squared ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <2o6dnUiVkpwkZxX_nZ2dnUU7_83NnZ2d@giganews.com>
<2l7iK.4210$3Gzd.996@fx96.iad>
<pbWdnQ8FgdkYlBT_nZ2dnUU7_83NnZ2d@giganews.com> <Rk8iK.97$oBkb.52@fx36.iad>
<Gr2dnQUB1by4jhT_nZ2dnUU7_8zNnZ2d@giganews.com>
<5A8iK.19830$zgr9.6127@fx13.iad>
<boKdnYDhXsgUihT_nZ2dnUU7_83NnZ2d@giganews.com> <iDaiK.48$CBlb.34@fx42.iad>
<hvydnRtx-KhkqxT_nZ2dnUU7_8xh4p2d@giganews.com> <hLaiK.52$CBlb.41@fx42.iad>
<buqdnb0TML8SpBT_nZ2dnUU7_8zNnZ2d@giganews.com>
<nSfiK.6234$IgSc.2259@fx45.iad>
<WKydnZZQmbU-FhT_nZ2dnUU7_83NnZ2d@giganews.com>
<9agiK.1050$gjlb.537@fx44.iad>
<I6idnSPl8NebDBT_nZ2dnUU7_81g4p2d@giganews.com>
<echiK.28776$J0r9.6239@fx11.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <echiK.28776$J0r9.6239@fx11.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <ZMadnSNEEuKCPBT_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 137
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-1ZN1lvDM7KuJArM0DE1UPMSXIfgvNJ02MHy5WUEs0iDHg/6U3Ks7b3lCJAlqeRSFwa7Z92AowJSulpH!g8nwY+yvAPzsuDGrCCTqMq4jL2tVga6RRrMIF0L8hki4GAXuKhcJ+/V6Fxa+GGvjgPiT8AmJSAQ=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 8267
View all headers
On 5/21/2022 9:27 PM, Richard Damon wrote:
On 5/21/22 9:25 PM, olcott wrote:
On 5/21/2022 8:16 PM, Richard Damon wrote:
On 5/21/22 9:02 PM, olcott wrote:
On 5/21/2022 7:55 PM, Richard Damon wrote:
On 5/21/22 3:12 PM, olcott wrote:
On 5/21/2022 2:06 PM, Richard Damon wrote:
On 5/21/22 3:01 PM, olcott wrote:
On 5/21/2022 1:58 PM, Richard Damon wrote:
On 5/21/22 12:47 PM, olcott wrote:
On 5/21/2022 11:38 AM, Richard Damon wrote:
On 5/21/22 12:28 PM, olcott wrote:
On 5/21/2022 11:22 AM, Richard Damon wrote:
On 5/21/22 11:47 AM, olcott wrote:
On 5/21/2022 10:14 AM, Richard Damon wrote:

On 5/21/22 10:44 AM, olcott wrote:
It is an easily verified fact that the execution trace provided by H(P,P) of the nested simulation of its input exactly matches the behavior of the correctly reverse-engineered nested execution trace would be.

No, it is easy to verify that it does NOT.
You know that you are a liar so I challenge you to provide the execution trace that a pure single level nested emulation of the input to H(P,P) would be. Any failure to provide this basis for your damned lies will be considered direct admission that you know you are lying.

_P()
[00001352](01)  55              push ebp
[00001353](02)  8bec            mov ebp,esp
[00001355](03)  8b4508          mov eax,[ebp+08]
[00001358](01)  50              push eax      // push P
[00001359](03)  8b4d08          mov ecx,[ebp+08]
[0000135c](01)  51              push ecx      // push P
[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]




Well, I wopuld need to have the code for H to do that, since that is PART of P.

It would begin as:

     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  =============
...[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

At this point I don't have the data,

The assumption is that H(P,P) correctly emulates its input.

Maybe a bad assumption!


It is stipulated that you must show what the execution trace of the input to H(P,P) would be if H only simulated its input. You must show this for one simulation and one nested simulation. Failure to do this will be construed as a direct admission that you know you are lying.




So, give me a copy of H to trace,
You are required to provide a trace under the assumption that H(P,P) only does a pure x86 emulation of its input for the first emulation and the first nested emulation. Are you too stupid to understand this?


You obviously have an reading problem.

I said, for that I need the code of H, as that is what needs to be traced.


If it is "given" that this code only performs a pure x86 emulation of its input (unless you have no idea what an x86 emulation is) there is no reason to see that the code derives a pure x86 emulation of its input.

The the trace of the emulation needs to show the actual steps of emulationg the input, like I mentioned.

If I showed either the source-code of H or the execution trace of H people here would be so confused that I would never reach closure in 50 years. If they can't comprehend a 14 line execution trace then showing them much more than this would permanently scramble their brains.

No, people wouldn't be confused,


That they don't understand that they don't need to see this conclusively proves that they have woefully inadequate technical skills to evaluate my work.


Just shows you are lying.

I coined the term "ignorance squared" decades ago to account for the fact that people cannot possibly be directly aware of their own ignorance.

To be directly aware of their own ignorance requires them to contrast their ignorance with the knowledge that they are missing.

Since they don't have this missing knowledge they cannot become directly aware that they are missing any knowledge. Their own ignorance is simply perceived as disagreement.

--
Copyright 2022 Pete Olcott

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


Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs [ ignorance squared ]
From: Richard Damon
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Organization: Forte - www.forteinc.com
Date: Sun, 22 May 2022 03:12 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx09.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.9.0
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting
problem proofs [ ignorance squared ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <2o6dnUiVkpwkZxX_nZ2dnUU7_83NnZ2d@giganews.com>
<2l7iK.4210$3Gzd.996@fx96.iad>
<pbWdnQ8FgdkYlBT_nZ2dnUU7_83NnZ2d@giganews.com> <Rk8iK.97$oBkb.52@fx36.iad>
<Gr2dnQUB1by4jhT_nZ2dnUU7_8zNnZ2d@giganews.com>
<5A8iK.19830$zgr9.6127@fx13.iad>
<boKdnYDhXsgUihT_nZ2dnUU7_83NnZ2d@giganews.com> <iDaiK.48$CBlb.34@fx42.iad>
<hvydnRtx-KhkqxT_nZ2dnUU7_8xh4p2d@giganews.com> <hLaiK.52$CBlb.41@fx42.iad>
<buqdnb0TML8SpBT_nZ2dnUU7_8zNnZ2d@giganews.com>
<nSfiK.6234$IgSc.2259@fx45.iad>
<WKydnZZQmbU-FhT_nZ2dnUU7_83NnZ2d@giganews.com>
<9agiK.1050$gjlb.537@fx44.iad>
<I6idnSPl8NebDBT_nZ2dnUU7_81g4p2d@giganews.com>
<echiK.28776$J0r9.6239@fx11.iad>
<ZMadnSNEEuKCPBT_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <ZMadnSNEEuKCPBT_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 152
Message-ID: <UShiK.11674$5fVf.6674@fx09.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 21 May 2022 23:12:52 -0400
X-Received-Bytes: 8904
View all headers
On 5/21/22 10:34 PM, olcott wrote:
On 5/21/2022 9:27 PM, Richard Damon wrote:
On 5/21/22 9:25 PM, olcott wrote:
On 5/21/2022 8:16 PM, Richard Damon wrote:
On 5/21/22 9:02 PM, olcott wrote:
On 5/21/2022 7:55 PM, Richard Damon wrote:
On 5/21/22 3:12 PM, olcott wrote:
On 5/21/2022 2:06 PM, Richard Damon wrote:
On 5/21/22 3:01 PM, olcott wrote:
On 5/21/2022 1:58 PM, Richard Damon wrote:
On 5/21/22 12:47 PM, olcott wrote:
On 5/21/2022 11:38 AM, Richard Damon wrote:
On 5/21/22 12:28 PM, olcott wrote:
On 5/21/2022 11:22 AM, Richard Damon wrote:
On 5/21/22 11:47 AM, olcott wrote:
On 5/21/2022 10:14 AM, Richard Damon wrote:

On 5/21/22 10:44 AM, olcott wrote:
It is an easily verified fact that the execution trace provided by H(P,P) of the nested simulation of its input exactly matches the behavior of the correctly reverse-engineered nested execution trace would be.

No, it is easy to verify that it does NOT.
You know that you are a liar so I challenge you to provide the execution trace that a pure single level nested emulation of the input to H(P,P) would be. Any failure to provide this basis for your damned lies will be considered direct admission that you know you are lying.

_P()
[00001352](01)  55              push ebp
[00001353](02)  8bec            mov ebp,esp
[00001355](03)  8b4508          mov eax,[ebp+08]
[00001358](01)  50              push eax      // push P
[00001359](03)  8b4d08          mov ecx,[ebp+08]
[0000135c](01)  51              push ecx      // push P
[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]




Well, I wopuld need to have the code for H to do that, since that is PART of P.

It would begin as:

     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  =============
...[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

At this point I don't have the data,

The assumption is that H(P,P) correctly emulates its input.

Maybe a bad assumption!


It is stipulated that you must show what the execution trace of the input to H(P,P) would be if H only simulated its input. You must show this for one simulation and one nested simulation. Failure to do this will be construed as a direct admission that you know you are lying.




So, give me a copy of H to trace,
You are required to provide a trace under the assumption that H(P,P) only does a pure x86 emulation of its input for the first emulation and the first nested emulation. Are you too stupid to understand this?


You obviously have an reading problem.

I said, for that I need the code of H, as that is what needs to be traced.


If it is "given" that this code only performs a pure x86 emulation of its input (unless you have no idea what an x86 emulation is) there is no reason to see that the code derives a pure x86 emulation of its input.

The the trace of the emulation needs to show the actual steps of emulationg the input, like I mentioned.

If I showed either the source-code of H or the execution trace of H people here would be so confused that I would never reach closure in 50 years. If they can't comprehend a 14 line execution trace then showing them much more than this would permanently scramble their brains.

No, people wouldn't be confused,


That they don't understand that they don't need to see this conclusively proves that they have woefully inadequate technical skills to evaluate my work.


Just shows you are lying.

I coined the term "ignorance squared" decades ago to account for the fact that people cannot possibly be directly aware of their own ignorance.

You seem tobe a good example of that.


To be directly aware of their own ignorance requires them to contrast their ignorance with the knowledge that they are missing.

Since they don't have this missing knowledge they cannot become directly aware that they are missing any knowledge. Their own ignorance is simply perceived as disagreement.

So, what actual FACT do you think I am missing?

I have stated specific rules that your 'claims' fail to follow. All you have done is hurled insults. Who doesn't actually know what they are talking about?

YOU are the one who has admitted to not having studied the theory, so don't have a real basis to judge what they do not know.

You are the perfect example of Dunning-Kruger Effect. (Maybe you didn't realize that the effect has an actual name because it has long been known).

One of your problems is that not having studied the history of the field, you repeat the exact same errors that have been previously committed.

I will say you are somewhat inventive in how you try to express these errors, but fundamentally many of them are ancient.


Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs [ ignorance squared ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Date: Sun, 22 May 2022 03:24 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 22:24:18 -0500
Date: Sat, 21 May 2022 22:24:16 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting
problem proofs [ ignorance squared ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <2o6dnUiVkpwkZxX_nZ2dnUU7_83NnZ2d@giganews.com>
<2l7iK.4210$3Gzd.996@fx96.iad>
<pbWdnQ8FgdkYlBT_nZ2dnUU7_83NnZ2d@giganews.com> <Rk8iK.97$oBkb.52@fx36.iad>
<Gr2dnQUB1by4jhT_nZ2dnUU7_8zNnZ2d@giganews.com>
<5A8iK.19830$zgr9.6127@fx13.iad>
<boKdnYDhXsgUihT_nZ2dnUU7_83NnZ2d@giganews.com> <iDaiK.48$CBlb.34@fx42.iad>
<hvydnRtx-KhkqxT_nZ2dnUU7_8xh4p2d@giganews.com> <hLaiK.52$CBlb.41@fx42.iad>
<buqdnb0TML8SpBT_nZ2dnUU7_8zNnZ2d@giganews.com>
<nSfiK.6234$IgSc.2259@fx45.iad>
<WKydnZZQmbU-FhT_nZ2dnUU7_83NnZ2d@giganews.com>
<9agiK.1050$gjlb.537@fx44.iad>
<I6idnSPl8NebDBT_nZ2dnUU7_81g4p2d@giganews.com>
<echiK.28776$J0r9.6239@fx11.iad>
<ZMadnSNEEuKCPBT_nZ2dnUU7_8zNnZ2d@giganews.com>
<UShiK.11674$5fVf.6674@fx09.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <UShiK.11674$5fVf.6674@fx09.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <EomdnXF6lJd_MRT_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 149
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-uofob4QYwrvcxDmyuyHlWWZYkydFym90cLUjqVLMOWV3KBsQGDUMOQFjp6bNXnqRFxqLi8EKcgO2ihk!V9UtMHlLhIdlpCgB4eicm7NQplOyRaj0OrLOgXuJTHmqZfpcRa3V+MD/35EBud3/QSqePy4hy0o=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 8954
View all headers
On 5/21/2022 10:12 PM, Richard Damon wrote:
On 5/21/22 10:34 PM, olcott wrote:
On 5/21/2022 9:27 PM, Richard Damon wrote:
On 5/21/22 9:25 PM, olcott wrote:
On 5/21/2022 8:16 PM, Richard Damon wrote:
On 5/21/22 9:02 PM, olcott wrote:
On 5/21/2022 7:55 PM, Richard Damon wrote:
On 5/21/22 3:12 PM, olcott wrote:
On 5/21/2022 2:06 PM, Richard Damon wrote:
On 5/21/22 3:01 PM, olcott wrote:
On 5/21/2022 1:58 PM, Richard Damon wrote:
On 5/21/22 12:47 PM, olcott wrote:
On 5/21/2022 11:38 AM, Richard Damon wrote:
On 5/21/22 12:28 PM, olcott wrote:
On 5/21/2022 11:22 AM, Richard Damon wrote:
On 5/21/22 11:47 AM, olcott wrote:
On 5/21/2022 10:14 AM, Richard Damon wrote:

On 5/21/22 10:44 AM, olcott wrote:
It is an easily verified fact that the execution trace provided by H(P,P) of the nested simulation of its input exactly matches the behavior of the correctly reverse-engineered nested execution trace would be.

No, it is easy to verify that it does NOT.
You know that you are a liar so I challenge you to provide the execution trace that a pure single level nested emulation of the input to H(P,P) would be. Any failure to provide this basis for your damned lies will be considered direct admission that you know you are lying.

_P()
[00001352](01)  55              push ebp
[00001353](02)  8bec            mov ebp,esp
[00001355](03)  8b4508          mov eax,[ebp+08]
[00001358](01)  50              push eax      // push P
[00001359](03)  8b4d08          mov ecx,[ebp+08]
[0000135c](01)  51              push ecx      // push P
[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]




Well, I wopuld need to have the code for H to do that, since that is PART of P.

It would begin as:

     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  =============
...[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

At this point I don't have the data,

The assumption is that H(P,P) correctly emulates its input.

Maybe a bad assumption!


It is stipulated that you must show what the execution trace of the input to H(P,P) would be if H only simulated its input. You must show this for one simulation and one nested simulation. Failure to do this will be construed as a direct admission that you know you are lying.




So, give me a copy of H to trace,
You are required to provide a trace under the assumption that H(P,P) only does a pure x86 emulation of its input for the first emulation and the first nested emulation. Are you too stupid to understand this?


You obviously have an reading problem.

I said, for that I need the code of H, as that is what needs to be traced.


If it is "given" that this code only performs a pure x86 emulation of its input (unless you have no idea what an x86 emulation is) there is no reason to see that the code derives a pure x86 emulation of its input.

The the trace of the emulation needs to show the actual steps of emulationg the input, like I mentioned.

If I showed either the source-code of H or the execution trace of H people here would be so confused that I would never reach closure in 50 years. If they can't comprehend a 14 line execution trace then showing them much more than this would permanently scramble their brains.

No, people wouldn't be confused,


That they don't understand that they don't need to see this conclusively proves that they have woefully inadequate technical skills to evaluate my work.


Just shows you are lying.

I coined the term "ignorance squared" decades ago to account for the fact that people cannot possibly be directly aware of their own ignorance.

You seem tobe a good example of that.


To be directly aware of their own ignorance requires them to contrast their ignorance with the knowledge that they are missing.

Since they don't have this missing knowledge they cannot become directly aware that they are missing any knowledge. Their own ignorance is simply perceived as disagreement.

So, what actual FACT do you think I am missing?
  That the next level execution trace of the input to H(P,P) must be identical to the first level trace.

--
Copyright 2022 Pete Olcott

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


Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs [ ignorance squared ]
From: Richard Damon
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Organization: Forte - www.forteinc.com
Date: Sun, 22 May 2022 03:37 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx13.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.9.0
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting
problem proofs [ ignorance squared ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <2o6dnUiVkpwkZxX_nZ2dnUU7_83NnZ2d@giganews.com>
<2l7iK.4210$3Gzd.996@fx96.iad>
<pbWdnQ8FgdkYlBT_nZ2dnUU7_83NnZ2d@giganews.com> <Rk8iK.97$oBkb.52@fx36.iad>
<Gr2dnQUB1by4jhT_nZ2dnUU7_8zNnZ2d@giganews.com>
<5A8iK.19830$zgr9.6127@fx13.iad>
<boKdnYDhXsgUihT_nZ2dnUU7_83NnZ2d@giganews.com> <iDaiK.48$CBlb.34@fx42.iad>
<hvydnRtx-KhkqxT_nZ2dnUU7_8xh4p2d@giganews.com> <hLaiK.52$CBlb.41@fx42.iad>
<buqdnb0TML8SpBT_nZ2dnUU7_8zNnZ2d@giganews.com>
<nSfiK.6234$IgSc.2259@fx45.iad>
<WKydnZZQmbU-FhT_nZ2dnUU7_83NnZ2d@giganews.com>
<9agiK.1050$gjlb.537@fx44.iad>
<I6idnSPl8NebDBT_nZ2dnUU7_81g4p2d@giganews.com>
<echiK.28776$J0r9.6239@fx11.iad>
<ZMadnSNEEuKCPBT_nZ2dnUU7_8zNnZ2d@giganews.com>
<UShiK.11674$5fVf.6674@fx09.iad>
<EomdnXF6lJd_MRT_nZ2dnUU7_81g4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <EomdnXF6lJd_MRT_nZ2dnUU7_81g4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 165
Message-ID: <deiiK.20029$zgr9.16856@fx13.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 21 May 2022 23:37:44 -0400
X-Received-Bytes: 9427
View all headers
On 5/21/22 11:24 PM, olcott wrote:
On 5/21/2022 10:12 PM, Richard Damon wrote:
On 5/21/22 10:34 PM, olcott wrote:
On 5/21/2022 9:27 PM, Richard Damon wrote:
On 5/21/22 9:25 PM, olcott wrote:
On 5/21/2022 8:16 PM, Richard Damon wrote:
On 5/21/22 9:02 PM, olcott wrote:
On 5/21/2022 7:55 PM, Richard Damon wrote:
On 5/21/22 3:12 PM, olcott wrote:
On 5/21/2022 2:06 PM, Richard Damon wrote:
On 5/21/22 3:01 PM, olcott wrote:
On 5/21/2022 1:58 PM, Richard Damon wrote:
On 5/21/22 12:47 PM, olcott wrote:
On 5/21/2022 11:38 AM, Richard Damon wrote:
On 5/21/22 12:28 PM, olcott wrote:
On 5/21/2022 11:22 AM, Richard Damon wrote:
On 5/21/22 11:47 AM, olcott wrote:
On 5/21/2022 10:14 AM, Richard Damon wrote:

On 5/21/22 10:44 AM, olcott wrote:
It is an easily verified fact that the execution trace provided by H(P,P) of the nested simulation of its input exactly matches the behavior of the correctly reverse-engineered nested execution trace would be.

No, it is easy to verify that it does NOT.
You know that you are a liar so I challenge you to provide the execution trace that a pure single level nested emulation of the input to H(P,P) would be. Any failure to provide this basis for your damned lies will be considered direct admission that you know you are lying.

_P()
[00001352](01)  55              push ebp
[00001353](02)  8bec            mov ebp,esp
[00001355](03)  8b4508          mov eax,[ebp+08]
[00001358](01)  50              push eax      // push P
[00001359](03)  8b4d08          mov ecx,[ebp+08]
[0000135c](01)  51              push ecx      // push P
[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]




Well, I wopuld need to have the code for H to do that, since that is PART of P.

It would begin as:

     machine   stack     stack     machine    assembly
     address   address   data      code       language
     ========  ========  ========  =========  =============
...[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

At this point I don't have the data,

The assumption is that H(P,P) correctly emulates its input.

Maybe a bad assumption!


It is stipulated that you must show what the execution trace of the input to H(P,P) would be if H only simulated its input. You must show this for one simulation and one nested simulation. Failure to do this will be construed as a direct admission that you know you are lying.




So, give me a copy of H to trace,
You are required to provide a trace under the assumption that H(P,P) only does a pure x86 emulation of its input for the first emulation and the first nested emulation. Are you too stupid to understand this?


You obviously have an reading problem.

I said, for that I need the code of H, as that is what needs to be traced.


If it is "given" that this code only performs a pure x86 emulation of its input (unless you have no idea what an x86 emulation is) there is no reason to see that the code derives a pure x86 emulation of its input.

The the trace of the emulation needs to show the actual steps of emulationg the input, like I mentioned.

If I showed either the source-code of H or the execution trace of H people here would be so confused that I would never reach closure in 50 years. If they can't comprehend a 14 line execution trace then showing them much more than this would permanently scramble their brains.

No, people wouldn't be confused,


That they don't understand that they don't need to see this conclusively proves that they have woefully inadequate technical skills to evaluate my work.


Just shows you are lying.

I coined the term "ignorance squared" decades ago to account for the fact that people cannot possibly be directly aware of their own ignorance.

You seem tobe a good example of that.


To be directly aware of their own ignorance requires them to contrast their ignorance with the knowledge that they are missing.

Since they don't have this missing knowledge they cannot become directly aware that they are missing any knowledge. Their own ignorance is simply perceived as disagreement.

So, what actual FACT do you think I am missing?
  That the next level execution trace of the input to H(P,P) must be identical to the first level trace.


But you don't put difffernt levels of execution in a single trace.

THAT is the fact that I have pointed out and you refuse to comment on.

That make YOU statement illogical.

You confuse simulation with direct execution.

Yes, and UNCONDITIONAL simulation will give the same net results as a direct exectution (when you take into account the indirection), but a conditional simulation need not.

The "Sequence of states" that are passed through by the ACTUAL execution hardware are different between a direct execution and a simulation, and the trace needs to represent that difference.

You are just showing how little you understand about how computaters work.



1
rocksolid light 0.7.2
clearneti2ptor