Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

I wish you humans would leave me alone.


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 proofsRichard 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 proofsRichard 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
H(P,P)==0 is proven to be correct thus refuting the halting problem proofs

<2o6dnUiVkpwkZxX_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8852&group=comp.ai.philosophy#8852

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.lang.c comp.lang.c++
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
 by: olcott - Sat, 21 May 2022 14:44 UTC

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

Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs

<2l7iK.4210$3Gzd.996@fx96.iad>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8853&group=comp.ai.philosophy#8853

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.lang.c comp.lang.c++
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
 by: Richard Damon - Sat, 21 May 2022 15:14 UTC

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.

Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs

<pbWdnQ8FgdkYlBT_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8854&group=comp.ai.philosophy#8854

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.lang.c comp.lang.c++
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
 by: olcott - Sat, 21 May 2022 15:47 UTC

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

Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs

<Rk8iK.97$oBkb.52@fx36.iad>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8855&group=comp.ai.philosophy#8855

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.lang.c comp.lang.c++
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
 by: Richard Damon - Sat, 21 May 2022 16:22 UTC

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
> ...[00000baf][001015c4][00000000](04) 837dfc00 cmp dword [ebp-04],+00
> ...[00000bb3][001015c4][00000000](02) 7402 jz 00000bb7
> ...[00000bb7][001015c8][001015d4](02) 8be5 mov esp,ebp
> ...[00000bb9][001015cc][00000bd5](01) 5d pop ebp
> ...[00000bba][001015d0][00000b98](01) c3 ret
> ...[00000bd5][001015d4][00000000](03) 83c404 add esp,+04
> ...[00000bd8][001015d4][00000000](02) 33c0 xor eax,eax
> ...[00000bda][001015d8][00100000](01) 5d pop ebp
> ...[00000bdb][001015dc][00000098](01) c3 ret

Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs

<Gr2dnQUB1by4jhT_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8856&group=comp.ai.philosophy#8856

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.lang.c comp.lang.c++
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
 by: olcott - Sat, 21 May 2022 16:28 UTC

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

Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs

<5A8iK.19830$zgr9.6127@fx13.iad>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8857&group=comp.ai.philosophy#8857

 copy link   Newsgroups: comp.theory comp.ai.philosophy
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
 by: Richard Damon - Sat, 21 May 2022 16:38 UTC

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.

Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs

<boKdnYDhXsgUihT_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8858&group=comp.ai.philosophy#8858

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: olcott - Sat, 21 May 2022 16:47 UTC

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

Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs

<YMudnQdaxd81hBT_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8859&group=comp.ai.philosophy#8859

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: olcott - Sat, 21 May 2022 16:56 UTC

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

Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs

<iDaiK.48$CBlb.34@fx42.iad>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8860&group=comp.ai.philosophy#8860

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: Richard Damon - Sat, 21 May 2022 18:58 UTC

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.

Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs

<hvydnRtx-KhkqxT_nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8861&group=comp.ai.philosophy#8861

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: olcott - Sat, 21 May 2022 19:01 UTC

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

Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs

<hLaiK.52$CBlb.41@fx42.iad>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8862&group=comp.ai.philosophy#8862

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: Richard Damon - Sat, 21 May 2022 19:06 UTC

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,

Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs

<buqdnb0TML8SpBT_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8863&group=comp.ai.philosophy#8863

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: olcott - Sat, 21 May 2022 19:12 UTC

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

Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs

<nSfiK.6234$IgSc.2259@fx45.iad>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8875&group=comp.ai.philosophy#8875

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: Richard Damon - Sun, 22 May 2022 00:55 UTC

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

Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs

<WKydnZZQmbU-FhT_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8878&group=comp.ai.philosophy#8878

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: olcott - Sun, 22 May 2022 01:02 UTC

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

Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs

<9agiK.1050$gjlb.537@fx44.iad>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8880&group=comp.ai.philosophy#8880

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: Richard Damon - Sun, 22 May 2022 01:16 UTC

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.

Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs

<I6idnSPl8NebDBT_nZ2dnUU7_81g4p2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8882&group=comp.ai.philosophy#8882

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: olcott - Sun, 22 May 2022 01:25 UTC

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

Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs

<echiK.28776$J0r9.6239@fx11.iad>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8884&group=comp.ai.philosophy#8884

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: Richard Damon - Sun, 22 May 2022 02:27 UTC

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.


Click here to read the complete article
Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs [ ignorance squared ]

<ZMadnSNEEuKCPBT_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8886&group=comp.ai.philosophy#8886

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: olcott - Sun, 22 May 2022 02:34 UTC

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.


Click here to read the complete article
Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs [ ignorance squared ]

<UShiK.11674$5fVf.6674@fx09.iad>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8888&group=comp.ai.philosophy#8888

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: Richard Damon - Sun, 22 May 2022 03:12 UTC

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.


Click here to read the complete article
Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs [ ignorance squared ]

<EomdnXF6lJd_MRT_nZ2dnUU7_81g4p2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8890&group=comp.ai.philosophy#8890

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: olcott - Sun, 22 May 2022 03:24 UTC

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.


Click here to read the complete article
Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs [ ignorance squared ]

<deiiK.20029$zgr9.16856@fx13.iad>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=8892&group=comp.ai.philosophy#8892

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
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
 by: Richard Damon - Sun, 22 May 2022 03:37 UTC

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


Click here to read the complete article
1
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor