Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

"Go to Heaven for the climate, Hell for the company." -- Mark Twain


devel / comp.theory / 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
`* H(P,P)==0 is proven to be correct thus refuting the haltingRichard Damon
 `* H(P,P)==0 is proven to be correct thus refuting the haltingolcott
  `* H(P,P)==0 is proven to be correct thus refuting the haltingRichard Damon
   `* H(P,P)==0 is proven to be correct thus refuting the haltingolcott
    `* H(P,P)==0 is proven to be correct thus refuting the haltingRichard Damon
     `* H(P,P)==0 is proven to be correct thus refuting the haltingolcott
      +* H(P,P)==0 is proven to be correct thus refuting the haltingDennis Bush
      |`* H(P,P)==0 is proven to be correct thus refuting the haltingolcott
      | `* H(P,P)==0 is proven to be correct thus refuting the haltingDennis Bush
      |  `* H(P,P)==0 is proven to be correct thus refuting the haltingolcott
      |   +* H(P,P)==0 is proven to be correct thus refuting the haltingPython
      |   |`- H(P,P)==0 is proven to be correct thus refuting the haltingolcott
      |   +* H(P,P)==0 is proven to be correct thus refuting the haltingDennis Bush
      |   |`* H(P,P)==0 is proven to be correct thus refuting the haltingolcott
      |   | `* H(P,P)==0 is proven to be correct thus refuting the haltingDennis Bush
      |   |  +- H(P,P)==0 is proven to be correct thus refuting the haltingolcott
      |   |  `* H(P,P)==0 is proven to be correct thus refuting the haltingolcott
      |   |   `* H(P,P)==0 is proven to be correct thus refuting the haltingRichard Damon
      |   |    `* H(P,P)==0 is proven to be correct thus refuting the haltingolcott
      |   |     `- H(P,P)==0 is proven to be correct thus refuting the halting problem proofsRichard Damon
      |   `* H(P,P)==0 is proven to be correct thus refuting the haltingRichard Damon
      |    `* H(P,P)==0 is proven to be correct thus refuting the haltingolcott
      |     `* H(P,P)==0 is proven to be correct thus refuting the haltingRichard Damon
      |      `* H(P,P)==0 is proven to be correct thus refuting the haltingolcott
      |       `- H(P,P)==0 is proven to be correct thus refuting the haltingRichard Damon
      `* H(P,P)==0 is proven to be correct thus refuting the halting problem proofsRichard Damon
       `* H(P,P)==0 is proven to be correct thus refuting the haltingolcott
        `* H(P,P)==0 is proven to be correct thus refuting the halting problem proofsRichard Damon
         `* H(P,P)==0 is proven to be correct thus refuting the haltingolcott
          `* H(P,P)==0 is proven to be correct thus refuting the haltingRichard Damon
           `* H(P,P)==0 is proven to be correct thus refuting the haltingolcott
            `* H(P,P)==0 is proven to be correct thus refuting the haltingRichard Damon
             `* H(P,P)==0 is proven to be correct thus refuting the haltingolcott
              `* H(P,P)==0 is proven to be correct thus refuting the haltingRichard Damon
               `* H(P,P)==0 is proven to be correct thus refuting the haltingolcott
                `* H(P,P)==0 is proven to be correct thus refuting the haltingRichard Damon
                 `* H(P,P)==0 is proven to be correct thus refuting the haltingolcott
                  `- H(P,P)==0 is proven to be correct thus refuting the haltingRichard Damon

Pages:12
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/devel/article-flat.php?id=32780&group=comp.theory#32780

 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/devel/article-flat.php?id=32781&group=comp.theory#32781

 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/devel/article-flat.php?id=32782&group=comp.theory#32782

 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/devel/article-flat.php?id=32783&group=comp.theory#32783

 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/devel/article-flat.php?id=32784&group=comp.theory#32784

 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/devel/article-flat.php?id=32785&group=comp.theory#32785

 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/devel/article-flat.php?id=32786&group=comp.theory#32786

 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

<646d7b34-6937-4bc7-910a-d075c2052534n@googlegroups.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32787&group=comp.theory#32787

 copy link   Newsgroups: comp.theory
X-Received: by 2002:ac8:5c96:0:b0:2f9:3077:5cda with SMTP id r22-20020ac85c96000000b002f930775cdamr1254252qta.625.1653151931550;
Sat, 21 May 2022 09:52:11 -0700 (PDT)
X-Received: by 2002:a81:a1c3:0:b0:2ff:53c6:6625 with SMTP id
y186-20020a81a1c3000000b002ff53c66625mr15397079ywg.99.1653151931401; Sat, 21
May 2022 09:52:11 -0700 (PDT)
Path: i2pn2.org!i2pn.org!paganini.bofh.team!pasdenom.info!nntpfeed.proxad.net!feeder1-1.proxad.net!proxad.net!feeder1-2.proxad.net!209.85.160.216.MISMATCH!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Sat, 21 May 2022 09:52:11 -0700 (PDT)
In-Reply-To: <boKdnYDhXsgUihT_nZ2dnUU7_83NnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=71.168.165.242; posting-account=ejFcQgoAAACAt5i0VbkATkR2ACWdgADD
NNTP-Posting-Host: 71.168.165.242
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>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <646d7b34-6937-4bc7-910a-d075c2052534n@googlegroups.com>
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting
problem proofs
From: dbush.mo...@gmail.com (Dennis Bush)
Injection-Date: Sat, 21 May 2022 16:52:11 +0000
Content-Type: text/plain; charset="UTF-8"
 by: Dennis Bush - Sat, 21 May 2022 16:52 UTC

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.

What you're actually asking for is to see the trace of Pn(Pn), where Pn calls Hn, and Hn does an unconditional simulation. Pn(Pn) has nothing to do with Pa(Pa) or Ha(Pa,Pa).

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/devel/article-flat.php?id=32788&group=comp.theory#32788

 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

<f233a48c-6a21-4851-8cd4-25598eaafb15n@googlegroups.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32790&group=comp.theory#32790

 copy link   Newsgroups: comp.theory
X-Received: by 2002:ae9:de43:0:b0:69f:7585:8276 with SMTP id s64-20020ae9de43000000b0069f75858276mr9458938qkf.706.1653154105839;
Sat, 21 May 2022 10:28:25 -0700 (PDT)
X-Received: by 2002:a0d:d801:0:b0:2fe:feb2:242a with SMTP id
a1-20020a0dd801000000b002fefeb2242amr15840727ywe.127.1653154105647; Sat, 21
May 2022 10:28:25 -0700 (PDT)
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!proxad.net!feeder1-2.proxad.net!209.85.160.216.MISMATCH!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Sat, 21 May 2022 10:28:25 -0700 (PDT)
In-Reply-To: <YMudnQdaxd81hBT_nZ2dnUU7_83NnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=71.168.165.242; posting-account=ejFcQgoAAACAt5i0VbkATkR2ACWdgADD
NNTP-Posting-Host: 71.168.165.242
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> <YMudnQdaxd81hBT_nZ2dnUU7_83NnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <f233a48c-6a21-4851-8cd4-25598eaafb15n@googlegroups.com>
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting
problem proofs
From: dbush.mo...@gmail.com (Dennis Bush)
Injection-Date: Sat, 21 May 2022 17:28:25 +0000
Content-Type: text/plain; charset="UTF-8"
 by: Dennis Bush - Sat, 21 May 2022 17:28 UTC

On Saturday, May 21, 2022 at 12:56:15 PM UTC-4, olcott wrote:
> 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,

But its algorithm *will* abort which is what matters.

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

In other words, only up to the point where Ha would abort, i.e. not long enough to see Pa(Pa) halt.

If we trace Hb(Pa,Pa) alongside Ha(Pa,Pa), we see that each trace is the same up to the point where Ha aborts. Hb then simulates this same input past the point that Ha is able to and finds that it reaches a final state and returns 1.

Therefore Hb(Pa,Pa)==1 conclusively proves that Ha(Pa,Pa)==0 is wrong because the latter is unable to simulate for long enough.

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

<msednd0IYIthvhT_nZ2dnUU7_81g4p2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32794&group=comp.theory#32794

 copy link   Newsgroups: comp.theory
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 12:40:12 -0500
Date: Sat, 21 May 2022 12:40:12 -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
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>
<YMudnQdaxd81hBT_nZ2dnUU7_83NnZ2d@giganews.com>
<f233a48c-6a21-4851-8cd4-25598eaafb15n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <f233a48c-6a21-4851-8cd4-25598eaafb15n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <msednd0IYIthvhT_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 88
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-KxswegERNgqUxGfXMkbu+Wba7yXcQsys8C3/BHCPt/fKv0ma9vbx/l4ghqYf5AXoYVkm7hcSrWsBD5h!Qus39r6C7t6a1c1l6SmZHHubTW4NPBg28c51bzquxEqZyjzX6ukHoMDBTwPudhS4HD1lD2WRaVw=
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: 5231
 by: olcott - Sat, 21 May 2022 17:40 UTC

On 5/21/2022 12:28 PM, Dennis Bush wrote:
> On Saturday, May 21, 2022 at 12:56:15 PM UTC-4, olcott wrote:
>> 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,
>
> But its algorithm *will* abort which is what matters.
>

When I ask to provide the execution trace of one correct x86 emulation
and and one nested x86 emulation of the input to H(P,P) dishonest lying
bastards keep trying to change the subject because they know that what I
ask for proves that I am 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

<t6b8vi$1e9s$1@gioia.aioe.org>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32799&group=comp.theory#32799

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!7a25jG6pUKCqa0zKnKnvdg.user.46.165.242.75.POSTED!not-for-mail
From: pyt...@example.invalid (Python)
Newsgroups: comp.theory
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting
problem proofs
Date: Sat, 21 May 2022 19:53:54 +0200
Organization: Aioe.org NNTP Server
Message-ID: <t6b8vi$1e9s$1@gioia.aioe.org>
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>
<YMudnQdaxd81hBT_nZ2dnUU7_83NnZ2d@giganews.com>
<f233a48c-6a21-4851-8cd4-25598eaafb15n@googlegroups.com>
<msednd0IYIthvhT_nZ2dnUU7_81g4p2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Info: gioia.aioe.org; logging-data="47420"; posting-host="7a25jG6pUKCqa0zKnKnvdg.user.gioia.aioe.org"; mail-complaints-to="abuse@aioe.org";
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:91.0)
Gecko/20100101 Thunderbird/91.9.0
Content-Language: fr
X-Notice: Filtered by postfilter v. 0.9.2
 by: Python - Sat, 21 May 2022 17:53 UTC

Peter Olcott wrote:
> On 5/21/2022 12:28 PM, Dennis Bush wrote:
>> On Saturday, May 21, 2022 at 12:56:15 PM UTC-4, olcott wrote:
>>> 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,
>>
>> But its algorithm *will* abort which is what matters.
>>
>
> When I ask to provide the execution trace of one correct x86 emulation
> and and one nested x86 emulation of the input to H(P,P) dishonest lying
> bastards keep trying to change the subject because they know that what I
> ask for proves that I am correct.

Says the guy who forged execution traces.

The lying baster is YOU Peter, you are a despicable piece of dirt that
will burn in Hell for ever.

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

<9ZKdnRrlLYB1uhT_nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32800&group=comp.theory#32800

 copy link   Newsgroups: comp.theory
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 12:56:56 -0500
Date: Sat, 21 May 2022 12:56:55 -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
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>
<YMudnQdaxd81hBT_nZ2dnUU7_83NnZ2d@giganews.com>
<f233a48c-6a21-4851-8cd4-25598eaafb15n@googlegroups.com>
<msednd0IYIthvhT_nZ2dnUU7_81g4p2d@giganews.com>
<t6b8vi$1e9s$1@gioia.aioe.org>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <t6b8vi$1e9s$1@gioia.aioe.org>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <9ZKdnRrlLYB1uhT_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 102
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-B19Xesx9LOq/sgDOJg7BsKJCEgFaYB8speUsbCGKjaMKJoZbFHYrC4u7wqx5QnJUU4txmvIm9D2azCB!u+JrLuvq/0AsUUAUGcF7wkeFxjfgcrFKP0d3ctHdSjFynvyjJUSwHz8rB6Y/jExlgQ3hhoIggZg=
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: 5944
 by: olcott - Sat, 21 May 2022 17:56 UTC

On 5/21/2022 12:53 PM, Python wrote:
> Peter Olcott wrote:
>> On 5/21/2022 12:28 PM, Dennis Bush wrote:
>>> On Saturday, May 21, 2022 at 12:56:15 PM UTC-4, olcott wrote:
>>>> 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,
>>>
>>> But its algorithm *will* abort which is what matters.
>>>
>>
>> When I ask to provide the execution trace of one correct x86 emulation
>> and and one nested x86 emulation of the input to H(P,P) dishonest
>> lying bastards keep trying to change the subject because they know
>> that what I ask for proves that I am correct.
>
> Says the guy who forged execution traces.
>
> The lying baster is YOU Peter, you are a despicable piece of dirt that
> will burn in Hell for ever.

If you weren't lying you would be able to show what the execution trace
should be and thus point out my error. That people provide only rhetoric
when I ask for specific logic proves that they are dishonest.

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

<ca77467d-0dd4-4959-9fa0-efa09cab1849n@googlegroups.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32801&group=comp.theory#32801

 copy link   Newsgroups: comp.theory
X-Received: by 2002:a05:6214:f29:b0:461:cf47:63eb with SMTP id iw9-20020a0562140f2900b00461cf4763ebmr11703526qvb.70.1653156243674;
Sat, 21 May 2022 11:04:03 -0700 (PDT)
X-Received: by 2002:a25:d209:0:b0:64e:405:bf40 with SMTP id
j9-20020a25d209000000b0064e0405bf40mr14868518ybg.101.1653156243477; Sat, 21
May 2022 11:04:03 -0700 (PDT)
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Sat, 21 May 2022 11:04:03 -0700 (PDT)
In-Reply-To: <msednd0IYIthvhT_nZ2dnUU7_81g4p2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=71.168.165.242; posting-account=ejFcQgoAAACAt5i0VbkATkR2ACWdgADD
NNTP-Posting-Host: 71.168.165.242
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> <YMudnQdaxd81hBT_nZ2dnUU7_83NnZ2d@giganews.com>
<f233a48c-6a21-4851-8cd4-25598eaafb15n@googlegroups.com> <msednd0IYIthvhT_nZ2dnUU7_81g4p2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <ca77467d-0dd4-4959-9fa0-efa09cab1849n@googlegroups.com>
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting
problem proofs
From: dbush.mo...@gmail.com (Dennis Bush)
Injection-Date: Sat, 21 May 2022 18:04:03 +0000
Content-Type: text/plain; charset="UTF-8"
X-Received-Bytes: 5870
 by: Dennis Bush - Sat, 21 May 2022 18:04 UTC

On Saturday, May 21, 2022 at 1:40:19 PM UTC-4, olcott wrote:
> On 5/21/2022 12:28 PM, Dennis Bush wrote:
> > On Saturday, May 21, 2022 at 12:56:15 PM UTC-4, olcott wrote:
> >> 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,
> >
> > But its algorithm *will* abort which is what matters.
> >
> When I ask to provide the execution trace of one correct x86 emulation
> and and one nested x86 emulation of the input to H(P,P) dishonest lying
> bastards keep trying to change the subject because they know that what I
> ask for proves that I am correct.

I gave you that, and *then* gave you the correct simulation of the remaining instructions which shows halting. Since you dishonestly clipped that part as it proved you wrong I'll put it back:

If we trace Hb(Pa,Pa) alongside Ha(Pa,Pa), we see that each trace is the same up to the point where Ha aborts. Hb then simulates this same input past the point that Ha is able to and finds that it reaches a final state and returns 1.

Therefore Hb(Pa,Pa)==1 conclusively proves that Ha(Pa,Pa)==0 is wrong because the latter is unable to simulate for long enough.

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

<YfKdncQaX_DUtxT_nZ2dnUU7_81g4p2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32802&group=comp.theory#32802

 copy link   Newsgroups: comp.theory
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 13:07:05 -0500
Date: Sat, 21 May 2022 13:07:05 -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
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>
<YMudnQdaxd81hBT_nZ2dnUU7_83NnZ2d@giganews.com>
<f233a48c-6a21-4851-8cd4-25598eaafb15n@googlegroups.com>
<msednd0IYIthvhT_nZ2dnUU7_81g4p2d@giganews.com>
<ca77467d-0dd4-4959-9fa0-efa09cab1849n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <ca77467d-0dd4-4959-9fa0-efa09cab1849n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <YfKdncQaX_DUtxT_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 95
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-1JKFmo88wJe/sjSfaOmsikzIvtNDB+v/h1XkB1WZ3zcrq/MTNbZYSSa8b5OAheiSXjedc1Bbc9wZW4q!RuMI7d6snHFRZkxMG8dAxC/2a0cmy4LWVFvjizocGQrcVXpazZY2+biS5aRI2nDd7vaa5mqkFmo=
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: 6019
 by: olcott - Sat, 21 May 2022 18:07 UTC

On 5/21/2022 1:04 PM, Dennis Bush wrote:
> On Saturday, May 21, 2022 at 1:40:19 PM UTC-4, olcott wrote:
>> On 5/21/2022 12:28 PM, Dennis Bush wrote:
>>> On Saturday, May 21, 2022 at 12:56:15 PM UTC-4, olcott wrote:
>>>> 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,
>>>
>>> But its algorithm *will* abort which is what matters.
>>>
>> When I ask to provide the execution trace of one correct x86 emulation
>> and and one nested x86 emulation of the input to H(P,P) dishonest lying
>> bastards keep trying to change the subject because they know that what I
>> ask for proves that I am correct.
>
> I gave you that, and *then* gave you the correct simulation of the remaining instructions which shows halting. Since you dishonestly clipped that part as it proved you wrong I'll put it back:
>
> If we trace Hb(Pa,Pa)

Dishonest lying bastards change the subject from the execution trace of
the input to H(P,P) by substituting and entirely different computation
as a dishonest lying bastard strawman error.

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

<aad2d89f-d486-4719-a7c1-2f53d05650c0n@googlegroups.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32803&group=comp.theory#32803

 copy link   Newsgroups: comp.theory
X-Received: by 2002:a05:6214:1bc7:b0:45b:85e:e5a4 with SMTP id m7-20020a0562141bc700b0045b085ee5a4mr11945584qvc.57.1653157171076;
Sat, 21 May 2022 11:19:31 -0700 (PDT)
X-Received: by 2002:a25:b683:0:b0:64b:8700:1358 with SMTP id
s3-20020a25b683000000b0064b87001358mr14264563ybj.282.1653157170879; Sat, 21
May 2022 11:19:30 -0700 (PDT)
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Sat, 21 May 2022 11:19:30 -0700 (PDT)
In-Reply-To: <YfKdncQaX_DUtxT_nZ2dnUU7_81g4p2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=71.168.165.242; posting-account=ejFcQgoAAACAt5i0VbkATkR2ACWdgADD
NNTP-Posting-Host: 71.168.165.242
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> <YMudnQdaxd81hBT_nZ2dnUU7_83NnZ2d@giganews.com>
<f233a48c-6a21-4851-8cd4-25598eaafb15n@googlegroups.com> <msednd0IYIthvhT_nZ2dnUU7_81g4p2d@giganews.com>
<ca77467d-0dd4-4959-9fa0-efa09cab1849n@googlegroups.com> <YfKdncQaX_DUtxT_nZ2dnUU7_81g4p2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <aad2d89f-d486-4719-a7c1-2f53d05650c0n@googlegroups.com>
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting
problem proofs
From: dbush.mo...@gmail.com (Dennis Bush)
Injection-Date: Sat, 21 May 2022 18:19:31 +0000
Content-Type: text/plain; charset="UTF-8"
X-Received-Bytes: 6560
 by: Dennis Bush - Sat, 21 May 2022 18:19 UTC

On Saturday, May 21, 2022 at 2:07:13 PM UTC-4, olcott wrote:
> On 5/21/2022 1:04 PM, Dennis Bush wrote:
> > On Saturday, May 21, 2022 at 1:40:19 PM UTC-4, olcott wrote:
> >> On 5/21/2022 12:28 PM, Dennis Bush wrote:
> >>> On Saturday, May 21, 2022 at 12:56:15 PM UTC-4, olcott wrote:
> >>>> 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,
> >>>
> >>> But its algorithm *will* abort which is what matters.
> >>>
> >> When I ask to provide the execution trace of one correct x86 emulation
> >> and and one nested x86 emulation of the input to H(P,P) dishonest lying
> >> bastards keep trying to change the subject because they know that what I
> >> ask for proves that I am correct.
> >
> > I gave you that, and *then* gave you the correct simulation of the remaining instructions which shows halting. Since you dishonestly clipped that part as it proved you wrong I'll put it back:
> >
> > If we trace Hb(Pa,Pa)
> Dishonest lying bastards change the subject from the execution trace of
> the input to H(P,P) by substituting and entirely different computation
> as a dishonest lying bastard strawman error.

It is NOT a different computation. Both Ha and Hb and halt deciders and both have the same input, so both are deciding on the same computation.

Therefore a trace of the input to Ha(Pa,Pa) is the same as a trace of the input to Hb(Pa,Pa).

They get different answers, so one must be wrong, and the one that simulates to a final state (i.e. Hb) is necessarily correct. Therefore Hb(Pa,Pa)==1 proves that Ha(Pa,Pa)==0 is wrong.

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

<3aSdnfDxVsgfsxT_nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32804&group=comp.theory#32804

 copy link   Newsgroups: comp.theory
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 13:25:06 -0500
Date: Sat, 21 May 2022 13:25: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
Content-Language: en-US
Newsgroups: comp.theory
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>
<YMudnQdaxd81hBT_nZ2dnUU7_83NnZ2d@giganews.com>
<f233a48c-6a21-4851-8cd4-25598eaafb15n@googlegroups.com>
<msednd0IYIthvhT_nZ2dnUU7_81g4p2d@giganews.com>
<ca77467d-0dd4-4959-9fa0-efa09cab1849n@googlegroups.com>
<YfKdncQaX_DUtxT_nZ2dnUU7_81g4p2d@giganews.com>
<aad2d89f-d486-4719-a7c1-2f53d05650c0n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <aad2d89f-d486-4719-a7c1-2f53d05650c0n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <3aSdnfDxVsgfsxT_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 100
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-oY3gym4NIlPHwhccwYeMjmVzDhLlZC6PjccoX0tl+b/yGHiZUUPyYuioKH1zZ7VR33H7XtgApj2EAsy!4G9npHTTLaVqu7T2a7nWH7j/OA6Mc8RJSYdUJAVptTFB9gMoeE9LSGgj05JNC0VKAr5fzQsJRuY=
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: 6508
 by: olcott - Sat, 21 May 2022 18:25 UTC

On 5/21/2022 1:19 PM, Dennis Bush wrote:
> On Saturday, May 21, 2022 at 2:07:13 PM UTC-4, olcott wrote:
>> On 5/21/2022 1:04 PM, Dennis Bush wrote:
>>> On Saturday, May 21, 2022 at 1:40:19 PM UTC-4, olcott wrote:
>>>> On 5/21/2022 12:28 PM, Dennis Bush wrote:
>>>>> On Saturday, May 21, 2022 at 12:56:15 PM UTC-4, olcott wrote:
>>>>>> 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,
>>>>>
>>>>> But its algorithm *will* abort which is what matters.
>>>>>
>>>> When I ask to provide the execution trace of one correct x86 emulation
>>>> and and one nested x86 emulation of the input to H(P,P) dishonest lying
>>>> bastards keep trying to change the subject because they know that what I
>>>> ask for proves that I am correct.
>>>
>>> I gave you that, and *then* gave you the correct simulation of the remaining instructions which shows halting. Since you dishonestly clipped that part as it proved you wrong I'll put it back:
>>>
>>> If we trace Hb(Pa,Pa)
>> Dishonest lying bastards change the subject from the execution trace of
>> the input to H(P,P) by substituting and entirely different computation
>> as a dishonest lying bastard strawman error.
>
> It is NOT a different computation.

Then don't dishonestly change the freaking name nitwit !!!

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

<hvydnRhx-Ki9qxT_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32808&group=comp.theory#32808

 copy link   Newsgroups: comp.theory
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 13:57:36 -0500
Date: Sat, 21 May 2022 13:57:35 -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
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>
<YMudnQdaxd81hBT_nZ2dnUU7_83NnZ2d@giganews.com>
<f233a48c-6a21-4851-8cd4-25598eaafb15n@googlegroups.com>
<msednd0IYIthvhT_nZ2dnUU7_81g4p2d@giganews.com>
<ca77467d-0dd4-4959-9fa0-efa09cab1849n@googlegroups.com>
<YfKdncQaX_DUtxT_nZ2dnUU7_81g4p2d@giganews.com>
<aad2d89f-d486-4719-a7c1-2f53d05650c0n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <aad2d89f-d486-4719-a7c1-2f53d05650c0n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <hvydnRhx-Ki9qxT_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 101
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-SuLdnbNc61DFr8yRAIIwrwbP8KTV7Q14EOp8SjKtIMQv5ACWDuAL8KdGQViyQNJnlR7dun5nUSZEUcW!It6uYnJAjooAaSfSJHtDbf8GBPt4xog3ysTIyw2OAlq4ihxNe/yU+hSNOL3zQoYtbPZNwkmf8+M=
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: 6588
 by: olcott - Sat, 21 May 2022 18:57 UTC

On 5/21/2022 1:19 PM, Dennis Bush wrote:
> On Saturday, May 21, 2022 at 2:07:13 PM UTC-4, olcott wrote:
>> On 5/21/2022 1:04 PM, Dennis Bush wrote:
>>> On Saturday, May 21, 2022 at 1:40:19 PM UTC-4, olcott wrote:
>>>> On 5/21/2022 12:28 PM, Dennis Bush wrote:
>>>>> On Saturday, May 21, 2022 at 12:56:15 PM UTC-4, olcott wrote:
>>>>>> 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,
>>>>>
>>>>> But its algorithm *will* abort which is what matters.
>>>>>
>>>> When I ask to provide the execution trace of one correct x86 emulation
>>>> and and one nested x86 emulation of the input to H(P,P) dishonest lying
>>>> bastards keep trying to change the subject because they know that what I
>>>> ask for proves that I am correct.
>>>
>>> I gave you that, and *then* gave you the correct simulation of the remaining instructions which shows halting. Since you dishonestly clipped that part as it proved you wrong I'll put it back:
>>>
>>> If we trace Hb(Pa,Pa)
>> Dishonest lying bastards change the subject from the execution trace of
>> the input to H(P,P) by substituting and entirely different computation
>> as a dishonest lying bastard strawman error.
>
> It is NOT a different computation.

So then you are too stupid to provide the correct execution trace of the
x86 emulation of the input to H(P,P) and one nested emulation?

--
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/devel/article-flat.php?id=32809&group=comp.theory#32809

 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/devel/article-flat.php?id=32810&group=comp.theory#32810

 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

<7GaiK.49$CBlb.16@fx42.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32811&group=comp.theory#32811

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.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
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>
<YMudnQdaxd81hBT_nZ2dnUU7_83NnZ2d@giganews.com>
<f233a48c-6a21-4851-8cd4-25598eaafb15n@googlegroups.com>
<msednd0IYIthvhT_nZ2dnUU7_81g4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <msednd0IYIthvhT_nZ2dnUU7_81g4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 99
Message-ID: <7GaiK.49$CBlb.16@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:01:23 -0400
X-Received-Bytes: 5347
 by: Richard Damon - Sat, 21 May 2022 19:01 UTC

On 5/21/22 1:40 PM, olcott wrote:
> On 5/21/2022 12:28 PM, Dennis Bush wrote:
>> On Saturday, May 21, 2022 at 12:56:15 PM UTC-4, olcott wrote:
>>> 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,
>>
>> But its algorithm *will* abort which is what matters.
>>
>
> When I ask to provide the execution trace of one correct x86 emulation
> and and one nested x86 emulation of the input to H(P,P) dishonest lying
> bastards keep trying to change the subject because they know that what I
> ask for proves that I am correct.
>

No, the fact that you ask for something that can't properly exist shows
you are an idiot.

A proper execution trace of a correct x86 emulation will show the stream
of instructions that the x86 processor will execute.

for the "nested" simulation, that is the instructions in the emulator
itself, NOT the instructions it is emulating.

You are asking for a Dog that is a Cat.

YOU are the lying bastard,

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

<lJaiK.51$CBlb.29@fx42.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32813&group=comp.theory#32813

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!feeder1.feed.usenet.farm!feed.usenet.farm!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
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>
<YMudnQdaxd81hBT_nZ2dnUU7_83NnZ2d@giganews.com>
<f233a48c-6a21-4851-8cd4-25598eaafb15n@googlegroups.com>
<msednd0IYIthvhT_nZ2dnUU7_81g4p2d@giganews.com>
<ca77467d-0dd4-4959-9fa0-efa09cab1849n@googlegroups.com>
<YfKdncQaX_DUtxT_nZ2dnUU7_81g4p2d@giganews.com>
<aad2d89f-d486-4719-a7c1-2f53d05650c0n@googlegroups.com>
<hvydnRhx-Ki9qxT_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <hvydnRhx-Ki9qxT_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 114
Message-ID: <lJaiK.51$CBlb.29@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:04:49 -0400
X-Received-Bytes: 6682
 by: Richard Damon - Sat, 21 May 2022 19:04 UTC

On 5/21/22 2:57 PM, olcott wrote:
> On 5/21/2022 1:19 PM, Dennis Bush wrote:
>> On Saturday, May 21, 2022 at 2:07:13 PM UTC-4, olcott wrote:
>>> On 5/21/2022 1:04 PM, Dennis Bush wrote:
>>>> On Saturday, May 21, 2022 at 1:40:19 PM UTC-4, olcott wrote:
>>>>> On 5/21/2022 12:28 PM, Dennis Bush wrote:
>>>>>> On Saturday, May 21, 2022 at 12:56:15 PM UTC-4, olcott wrote:
>>>>>>> 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,
>>>>>>
>>>>>> But its algorithm *will* abort which is what matters.
>>>>>>
>>>>> When I ask to provide the execution trace of one correct x86 emulation
>>>>> and and one nested x86 emulation of the input to H(P,P) dishonest
>>>>> lying
>>>>> bastards keep trying to change the subject because they know that
>>>>> what I
>>>>> ask for proves that I am correct.
>>>>
>>>> I gave you that, and *then* gave you the correct simulation of the
>>>> remaining instructions which shows halting. Since you dishonestly
>>>> clipped that part as it proved you wrong I'll put it back:
>>>>
>>>> If we trace Hb(Pa,Pa)
>>> Dishonest lying bastards change the subject from the execution trace of
>>> the input to H(P,P) by substituting and entirely different computation
>>> as a dishonest lying bastard strawman error.
>>
>> It is NOT a different computation.
>
> So then you are too stupid to provide the correct execution trace of the
> x86 emulation of the input to H(P,P) and one nested emulation?
>
>

And you are to stupid to understand that this is asking for a square circle.

One execution trace should NEVER show two different levels of execution
behavior,

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

<hvydnRpx-Kh1qhT_nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32814&group=comp.theory#32814

 copy link   Newsgroups: comp.theory
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:05:12 -0500
Date: Sat, 21 May 2022 14:05:11 -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
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>
<YMudnQdaxd81hBT_nZ2dnUU7_83NnZ2d@giganews.com>
<f233a48c-6a21-4851-8cd4-25598eaafb15n@googlegroups.com>
<msednd0IYIthvhT_nZ2dnUU7_81g4p2d@giganews.com> <7GaiK.49$CBlb.16@fx42.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <7GaiK.49$CBlb.16@fx42.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <hvydnRpx-Kh1qhT_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 100
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-HEiY1c6llOo1z1OnF8udt9GJpZ+4d+tv2dgls6Ww/i6lAr6YYhS9Fzu0w+MhTbIEjwnr7i8TEBob/5h!eoZrw02zvevL+M1CK7luk7SBVaVB4EAfjH3nIfbllDG1y94PkZ3rB2MHSo+53lk2ZpOLm96y6EM=
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: 5815
 by: olcott - Sat, 21 May 2022 19:05 UTC

On 5/21/2022 2:01 PM, Richard Damon wrote:
> On 5/21/22 1:40 PM, olcott wrote:
>> On 5/21/2022 12:28 PM, Dennis Bush wrote:
>>> On Saturday, May 21, 2022 at 12:56:15 PM UTC-4, olcott wrote:
>>>> 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,
>>>
>>> But its algorithm *will* abort which is what matters.
>>>
>>
>> When I ask to provide the execution trace of one correct x86 emulation
>> and and one nested x86 emulation of the input to H(P,P) dishonest
>> lying bastards keep trying to change the subject because they know
>> that what I ask for proves that I am correct.
>>
>
>
> No, the fact that you ask for something that can't properly exist shows
> you are an idiot.
>
Saying the an x86 emulation of x86 machine code it impossible is
ridiculously stupid thing to say (and you know it).

--
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/devel/article-flat.php?id=32815&group=comp.theory#32815

 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

<hvydnRVx-KjhpRT_nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=32816&group=comp.theory#32816

 copy link   Newsgroups: comp.theory
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:07:40 -0500
Date: Sat, 21 May 2022 14:07:39 -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
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>
<YMudnQdaxd81hBT_nZ2dnUU7_83NnZ2d@giganews.com>
<f233a48c-6a21-4851-8cd4-25598eaafb15n@googlegroups.com>
<msednd0IYIthvhT_nZ2dnUU7_81g4p2d@giganews.com>
<ca77467d-0dd4-4959-9fa0-efa09cab1849n@googlegroups.com>
<YfKdncQaX_DUtxT_nZ2dnUU7_81g4p2d@giganews.com>
<aad2d89f-d486-4719-a7c1-2f53d05650c0n@googlegroups.com>
<hvydnRhx-Ki9qxT_nZ2dnUU7_8zNnZ2d@giganews.com> <lJaiK.51$CBlb.29@fx42.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <lJaiK.51$CBlb.29@fx42.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <hvydnRVx-KjhpRT_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 129
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Bcyf3oDH4T0hT2DfGL94b49I8CJsaynPO+4fbsgUCtIE2rNThQw37eJVH/i/G26IVP37bX9zrq4ozVd!sftnG1p/lkjlRYMuYYGtRFs/hqiDfLFa0Sd7O4UXGk8lA2DBjLuDxn1mr6H6oHeKHkJUIzaYDJw=
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: 7417
 by: olcott - Sat, 21 May 2022 19:07 UTC

On 5/21/2022 2:04 PM, Richard Damon wrote:
> On 5/21/22 2:57 PM, olcott wrote:
>> On 5/21/2022 1:19 PM, Dennis Bush wrote:
>>> On Saturday, May 21, 2022 at 2:07:13 PM UTC-4, olcott wrote:
>>>> On 5/21/2022 1:04 PM, Dennis Bush wrote:
>>>>> On Saturday, May 21, 2022 at 1:40:19 PM UTC-4, olcott wrote:
>>>>>> On 5/21/2022 12:28 PM, Dennis Bush wrote:
>>>>>>> On Saturday, May 21, 2022 at 12:56:15 PM UTC-4, olcott wrote:
>>>>>>>> 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,
>>>>>>>
>>>>>>> But its algorithm *will* abort which is what matters.
>>>>>>>
>>>>>> When I ask to provide the execution trace of one correct x86
>>>>>> emulation
>>>>>> and and one nested x86 emulation of the input to H(P,P) dishonest
>>>>>> lying
>>>>>> bastards keep trying to change the subject because they know that
>>>>>> what I
>>>>>> ask for proves that I am correct.
>>>>>
>>>>> I gave you that, and *then* gave you the correct simulation of the
>>>>> remaining instructions which shows halting. Since you dishonestly
>>>>> clipped that part as it proved you wrong I'll put it back:
>>>>>
>>>>> If we trace Hb(Pa,Pa)
>>>> Dishonest lying bastards change the subject from the execution trace of
>>>> the input to H(P,P) by substituting and entirely different computation
>>>> as a dishonest lying bastard strawman error.
>>>
>>> It is NOT a different computation.
>>
>> So then you are too stupid to provide the correct execution trace of
>> the x86 emulation of the input to H(P,P) and one nested emulation?
>>
>>
>
> And you are to stupid to understand that this is asking for a square
> circle.
>
> One execution trace should NEVER show two different levels of execution
> behavior,

The first level drives the second level, thus the second level is an
aspect of the first level.

--
Copyright 2022 Pete Olcott

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

Pages:12
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor