Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Somebody's terminal is dropping bits. I found a pile of them over in the corner.


devel / comp.theory / Re: H(P,P)==0 is proven to be correct thus refuting the halting problem proofs [ ignorance squared ]

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

<buqdnb0TML8SpBT_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

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

On 5/21/2022 2:06 PM, Richard Damon wrote:
> On 5/21/22 3:01 PM, olcott wrote:
>> On 5/21/2022 1:58 PM, Richard Damon wrote:
>>> On 5/21/22 12:47 PM, olcott wrote:
>>>> On 5/21/2022 11:38 AM, Richard Damon wrote:
>>>>> On 5/21/22 12:28 PM, olcott wrote:
>>>>>> On 5/21/2022 11:22 AM, Richard Damon wrote:
>>>>>>> On 5/21/22 11:47 AM, olcott wrote:
>>>>>>>> On 5/21/2022 10:14 AM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 5/21/22 10:44 AM, olcott wrote:
>>>>>>>>>> It is an easily verified fact that the execution trace
>>>>>>>>>> provided by H(P,P) of the nested simulation of its input
>>>>>>>>>> exactly matches the behavior of the correctly
>>>>>>>>>> reverse-engineered nested execution trace would be.
>>>>>>>>>
>>>>>>>>> No, it is easy to verify that it does NOT.
>>>>>>>> You know that you are a liar so I challenge you to provide the
>>>>>>>> execution trace that a pure single level nested emulation of the
>>>>>>>> input to H(P,P) would be. Any failure to provide this basis for
>>>>>>>> your damned lies will be considered direct admission that you
>>>>>>>> know you are lying.
>>>>>>>>
>>>>>>>> _P()
>>>>>>>> [00001352](01)  55              push ebp
>>>>>>>> [00001353](02)  8bec            mov ebp,esp
>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08]
>>>>>>>> [00001358](01)  50              push eax      // push P
>>>>>>>> [00001359](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>> [0000135c](01)  51              push ecx      // push P
>>>>>>>> [0000135d](05)  e840feffff      call 000011a2 // call H
>>>>>>>> [00001362](03)  83c408          add esp,+08
>>>>>>>> [00001365](02)  85c0            test eax,eax
>>>>>>>> [00001367](02)  7402            jz 0000136b
>>>>>>>> [00001369](02)  ebfe            jmp 00001369
>>>>>>>> [0000136b](01)  5d              pop ebp
>>>>>>>> [0000136c](01)  c3              ret
>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> Well, I wopuld need to have the code for H to do that, since that
>>>>>>> is PART of P.
>>>>>>>
>>>>>>> It would begin as:
>>>>>>>
>>>>>>>      machine   stack     stack     machine    assembly
>>>>>>>      address   address   data      code       language
>>>>>>>      ========  ========  ========  =========  =============
>>>>>>> ...[00001352][0021233e][00212342] 55         push ebp      //
>>>>>>> enter P
>>>>>>> ...[00001353][0021233e][00212342] 8bec       mov ebp,esp
>>>>>>> ...[00001355][0021233e][00212342] 8b4508     mov eax,[ebp+08]
>>>>>>> ...[00001358][0021233a][00001352] 50         push eax      // push P
>>>>>>> ...[00001359][0021233a][00001352] 8b4d08     mov ecx,[ebp+08]
>>>>>>> ...[0000135c][00212336][00001352] 51         push ecx      // push P
>>>>>>> ...[0000135d][00212332][00001362] e840feffff call 000011a2 // call H
>>>>>>>
>>>>>>> At this point I don't have the data,
>>>>>>
>>>>>> The assumption is that H(P,P) correctly emulates its input.
>>>>>
>>>>> Maybe a bad assumption!
>>>>>
>>>>
>>>> It is stipulated that you must show what the execution trace of the
>>>> input to H(P,P) would be if H only simulated its input. You must
>>>> show this for one simulation and one nested simulation. Failure to
>>>> do this will be construed as a direct admission that you know you
>>>> are lying.
>>>>
>>>>
>>>>
>>>
>>> So, give me a copy of H to trace,
>> You are required to provide a trace under the assumption that H(P,P)
>> only does a pure x86 emulation of its input for the first emulation
>> and the first nested emulation. Are you too stupid to understand this?
>>
>
> You obviously have an reading problem.
>
> I said, for that I need the code of H, as that is what needs to be traced.
>

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

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

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

> To say otherwise just proves you are s stupid liar,
>
> How else can you show an emulation of an emulator unless you have the
> code that is doing the emulation that needs to be shown,
>
>

--
Copyright 2022 Pete Olcott

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

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

<RLfiK.1176$lW.1168@fx38.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!3.eu.feeder.erje.net!feeder.erje.net!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!fx38.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> <lJaiK.51$CBlb.29@fx42.iad> <hvydnRVx-KjhpRT_nZ2dnUU7_8xh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <hvydnRVx-KjhpRT_nZ2dnUU7_8xh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 162
Message-ID: <RLfiK.1176$lW.1168@fx38.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 21 May 2022 20:48:48 -0400
X-Received-Bytes: 8474
 by: Richard Damon - Sun, 22 May 2022 00:48 UTC

On 5/21/22 3:07 PM, olcott wrote:
> 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.
>

But it isn't the execution trace of the first level.


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

<CPfiK.6233$IgSc.3703@fx45.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx45.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.9.0
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting
problem proofs
Content-Language: en-US
Newsgroups: comp.theory
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>
<hvydnRpx-Kh1qhT_nZ2dnUU7_8xh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <hvydnRpx-Kh1qhT_nZ2dnUU7_8xh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 109
Message-ID: <CPfiK.6233$IgSc.3703@fx45.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 21 May 2022 20:52:49 -0400
X-Received-Bytes: 6089
 by: Richard Damon - Sun, 22 May 2022 00:52 UTC

On 5/21/22 3:05 PM, olcott wrote:
> 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).
>

No, that isn't what is impossible, what is impossible is to correctly
represent that by a trace of the second level of code, since that isn't
what actually happens.

If you beleive it is ok to just LIE in your proof, than just admit that
you don't care what is actually truth, just that you can fake a proof of
your incorrect claim.

THe ONLY case that comes close to making your trace valid is if H is
just an immediate call of its input, but then it can't abort its
"simulation" since it isn't in control with out failing to be a
computation.

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

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

 copy mid

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

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

On 5/21/22 3:12 PM, olcott wrote:
> On 5/21/2022 2:06 PM, Richard Damon wrote:
>> On 5/21/22 3:01 PM, olcott wrote:
>>> On 5/21/2022 1:58 PM, Richard Damon wrote:
>>>> On 5/21/22 12:47 PM, olcott wrote:
>>>>> On 5/21/2022 11:38 AM, Richard Damon wrote:
>>>>>> On 5/21/22 12:28 PM, olcott wrote:
>>>>>>> On 5/21/2022 11:22 AM, Richard Damon wrote:
>>>>>>>> On 5/21/22 11:47 AM, olcott wrote:
>>>>>>>>> On 5/21/2022 10:14 AM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 5/21/22 10:44 AM, olcott wrote:
>>>>>>>>>>> It is an easily verified fact that the execution trace
>>>>>>>>>>> provided by H(P,P) of the nested simulation of its input
>>>>>>>>>>> exactly matches the behavior of the correctly
>>>>>>>>>>> reverse-engineered nested execution trace would be.
>>>>>>>>>>
>>>>>>>>>> No, it is easy to verify that it does NOT.
>>>>>>>>> You know that you are a liar so I challenge you to provide the
>>>>>>>>> execution trace that a pure single level nested emulation of
>>>>>>>>> the input to H(P,P) would be. Any failure to provide this basis
>>>>>>>>> for your damned lies will be considered direct admission that
>>>>>>>>> you know you are lying.
>>>>>>>>>
>>>>>>>>> _P()
>>>>>>>>> [00001352](01)  55              push ebp
>>>>>>>>> [00001353](02)  8bec            mov ebp,esp
>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>> [00001358](01)  50              push eax      // push P
>>>>>>>>> [00001359](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>> [0000135c](01)  51              push ecx      // push P
>>>>>>>>> [0000135d](05)  e840feffff      call 000011a2 // call H
>>>>>>>>> [00001362](03)  83c408          add esp,+08
>>>>>>>>> [00001365](02)  85c0            test eax,eax
>>>>>>>>> [00001367](02)  7402            jz 0000136b
>>>>>>>>> [00001369](02)  ebfe            jmp 00001369
>>>>>>>>> [0000136b](01)  5d              pop ebp
>>>>>>>>> [0000136c](01)  c3              ret
>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> Well, I wopuld need to have the code for H to do that, since
>>>>>>>> that is PART of P.
>>>>>>>>
>>>>>>>> It would begin as:
>>>>>>>>
>>>>>>>>      machine   stack     stack     machine    assembly
>>>>>>>>      address   address   data      code       language
>>>>>>>>      ========  ========  ========  =========  =============
>>>>>>>> ...[00001352][0021233e][00212342] 55         push ebp      //
>>>>>>>> enter P
>>>>>>>> ...[00001353][0021233e][00212342] 8bec       mov ebp,esp
>>>>>>>> ...[00001355][0021233e][00212342] 8b4508     mov eax,[ebp+08]
>>>>>>>> ...[00001358][0021233a][00001352] 50         push eax      //
>>>>>>>> push P
>>>>>>>> ...[00001359][0021233a][00001352] 8b4d08     mov ecx,[ebp+08]
>>>>>>>> ...[0000135c][00212336][00001352] 51         push ecx      //
>>>>>>>> push P
>>>>>>>> ...[0000135d][00212332][00001362] e840feffff call 000011a2 //
>>>>>>>> call H
>>>>>>>>
>>>>>>>> At this point I don't have the data,
>>>>>>>
>>>>>>> The assumption is that H(P,P) correctly emulates its input.
>>>>>>
>>>>>> Maybe a bad assumption!
>>>>>>
>>>>>
>>>>> It is stipulated that you must show what the execution trace of the
>>>>> input to H(P,P) would be if H only simulated its input. You must
>>>>> show this for one simulation and one nested simulation. Failure to
>>>>> do this will be construed as a direct admission that you know you
>>>>> are lying.
>>>>>
>>>>>
>>>>>
>>>>
>>>> So, give me a copy of H to trace,
>>> You are required to provide a trace under the assumption that H(P,P)
>>> only does a pure x86 emulation of its input for the first emulation
>>> and the first nested emulation. Are you too stupid to understand this?
>>>
>>
>> You obviously have an reading problem.
>>
>> I said, for that I need the code of H, as that is what needs to be
>> traced.
>>
>
> If it is "given" that this code only performs a pure x86 emulation of
> its input (unless you have no idea what an x86 emulation is) there is no
> reason to see that the code derives a pure x86 emulation of its input.

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

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

Maybe YOU don't understand what an emulator does.

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

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

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

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

>
>> To say otherwise just proves you are s stupid liar,
>>
>> How else can you show an emulation of an emulator unless you have the
>> code that is doing the emulation that needs to be shown,
>>
>>
>
>

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

<A-idnSV4h5OxFxT_nZ2dnUU7_81g4p2d@giganews.com>

 copy mid

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

 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 19:56:12 -0500
Date: Sat, 21 May 2022 19:56: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>
<hvydnRpx-Kh1qhT_nZ2dnUU7_8xh4p2d@giganews.com>
<CPfiK.6233$IgSc.3703@fx45.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <CPfiK.6233$IgSc.3703@fx45.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <A-idnSV4h5OxFxT_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 113
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-AWwO+Li+kRglLNN/Z/RR5r5aWNVt9193ToKcS8HX+yv6kBnEwgf9elsZKvE+GFc/umOqzOi8LP1jIay!ZxTmG15QKpyN8W95SmR6x6fJ+Djxxto8d6sIQBpBqKuMpjDfc6gV/U9mcW0WZcrgpIB+lwoHZlE=
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: 6462
 by: olcott - Sun, 22 May 2022 00:56 UTC

On 5/21/2022 7:52 PM, Richard Damon wrote:
> On 5/21/22 3:05 PM, olcott wrote:
>> 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).
>>
>
> No, that isn't what is impossible, what is impossible is to correctly
> represent that by a trace of the second level of code, since that isn't
> what actually happens.
>

So when P calls H(P,P) you are saying that P is not calling H(P,P) ?

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

<WKydnZZQmbU-FhT_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

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

On 5/21/2022 7:55 PM, Richard Damon wrote:
> On 5/21/22 3:12 PM, olcott wrote:
>> On 5/21/2022 2:06 PM, Richard Damon wrote:
>>> On 5/21/22 3:01 PM, olcott wrote:
>>>> On 5/21/2022 1:58 PM, Richard Damon wrote:
>>>>> On 5/21/22 12:47 PM, olcott wrote:
>>>>>> On 5/21/2022 11:38 AM, Richard Damon wrote:
>>>>>>> On 5/21/22 12:28 PM, olcott wrote:
>>>>>>>> On 5/21/2022 11:22 AM, Richard Damon wrote:
>>>>>>>>> On 5/21/22 11:47 AM, olcott wrote:
>>>>>>>>>> On 5/21/2022 10:14 AM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 5/21/22 10:44 AM, olcott wrote:
>>>>>>>>>>>> It is an easily verified fact that the execution trace
>>>>>>>>>>>> provided by H(P,P) of the nested simulation of its input
>>>>>>>>>>>> exactly matches the behavior of the correctly
>>>>>>>>>>>> reverse-engineered nested execution trace would be.
>>>>>>>>>>>
>>>>>>>>>>> No, it is easy to verify that it does NOT.
>>>>>>>>>> You know that you are a liar so I challenge you to provide the
>>>>>>>>>> execution trace that a pure single level nested emulation of
>>>>>>>>>> the input to H(P,P) would be. Any failure to provide this
>>>>>>>>>> basis for your damned lies will be considered direct admission
>>>>>>>>>> that you know you are lying.
>>>>>>>>>>
>>>>>>>>>> _P()
>>>>>>>>>> [00001352](01)  55              push ebp
>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp
>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>>> [00001358](01)  50              push eax      // push P
>>>>>>>>>> [00001359](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>>> [0000135c](01)  51              push ecx      // push P
>>>>>>>>>> [0000135d](05)  e840feffff      call 000011a2 // call H
>>>>>>>>>> [00001362](03)  83c408          add esp,+08
>>>>>>>>>> [00001365](02)  85c0            test eax,eax
>>>>>>>>>> [00001367](02)  7402            jz 0000136b
>>>>>>>>>> [00001369](02)  ebfe            jmp 00001369
>>>>>>>>>> [0000136b](01)  5d              pop ebp
>>>>>>>>>> [0000136c](01)  c3              ret
>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Well, I wopuld need to have the code for H to do that, since
>>>>>>>>> that is PART of P.
>>>>>>>>>
>>>>>>>>> It would begin as:
>>>>>>>>>
>>>>>>>>>      machine   stack     stack     machine    assembly
>>>>>>>>>      address   address   data      code       language
>>>>>>>>>      ========  ========  ========  =========  =============
>>>>>>>>> ...[00001352][0021233e][00212342] 55         push ebp      //
>>>>>>>>> enter P
>>>>>>>>> ...[00001353][0021233e][00212342] 8bec       mov ebp,esp
>>>>>>>>> ...[00001355][0021233e][00212342] 8b4508     mov eax,[ebp+08]
>>>>>>>>> ...[00001358][0021233a][00001352] 50         push eax      //
>>>>>>>>> push P
>>>>>>>>> ...[00001359][0021233a][00001352] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>> ...[0000135c][00212336][00001352] 51         push ecx      //
>>>>>>>>> push P
>>>>>>>>> ...[0000135d][00212332][00001362] e840feffff call 000011a2 //
>>>>>>>>> call H
>>>>>>>>>
>>>>>>>>> At this point I don't have the data,
>>>>>>>>
>>>>>>>> The assumption is that H(P,P) correctly emulates its input.
>>>>>>>
>>>>>>> Maybe a bad assumption!
>>>>>>>
>>>>>>
>>>>>> It is stipulated that you must show what the execution trace of
>>>>>> the input to H(P,P) would be if H only simulated its input. You
>>>>>> must show this for one simulation and one nested simulation.
>>>>>> Failure to do this will be construed as a direct admission that
>>>>>> you know you are lying.
>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>> So, give me a copy of H to trace,
>>>> You are required to provide a trace under the assumption that H(P,P)
>>>> only does a pure x86 emulation of its input for the first emulation
>>>> and the first nested emulation. Are you too stupid to understand this?
>>>>
>>>
>>> You obviously have an reading problem.
>>>
>>> I said, for that I need the code of H, as that is what needs to be
>>> traced.
>>>
>>
>> If it is "given" that this code only performs a pure x86 emulation of
>> its input (unless you have no idea what an x86 emulation is) there is
>> no reason to see that the code derives a pure x86 emulation of its input.
>
> The the trace of the emulation needs to show the actual steps of
> emulationg the input, like I mentioned.
>
If I showed either the source-code of H or the execution trace of H
people here would be so confused that I would never reach closure in 50
years. If they can't comprehend a 14 line execution trace then showing
them much more than this would permanently scramble their brains.

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

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

--
Copyright 2022 Pete Olcott

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

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

<92giK.28448$J0r9.11789@fx11.iad>

 copy mid

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

 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!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx11.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.9.0
Subject: Re: H(P,P)==0 is proven to be correct thus refuting the halting
problem proofs
Content-Language: en-US
Newsgroups: comp.theory
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>
<hvydnRpx-Kh1qhT_nZ2dnUU7_8xh4p2d@giganews.com>
<CPfiK.6233$IgSc.3703@fx45.iad>
<A-idnSV4h5OxFxT_nZ2dnUU7_81g4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <A-idnSV4h5OxFxT_nZ2dnUU7_81g4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 123
Message-ID: <92giK.28448$J0r9.11789@fx11.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 21 May 2022 21:08:21 -0400
X-Received-Bytes: 6666
X-Original-Bytes: 6533
 by: Richard Damon - Sun, 22 May 2022 01:08 UTC

On 5/21/22 8:56 PM, olcott wrote:
> On 5/21/2022 7:52 PM, Richard Damon wrote:
>> On 5/21/22 3:05 PM, olcott wrote:
>>> 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).
>>>
>>
>> No, that isn't what is impossible, what is impossible is to correctly
>> represent that by a trace of the second level of code, since that
>> isn't what actually happens.
>>
>
> So when P calls H(P,P) you are saying that P is not calling H(P,P) ?
>

You don't understand anything do you.

P does call H(P,P), and so an execution trace of P needs to show the
instructions IN H, that are being executed as it performs its simulation
and halt decision of the input.

H does NOT call P, not if it is able to abort its "simulation" of its input.

Your "Second Level" isn't anything that actually gets executed in the
program, just simulated in the simulation.

Are you admitting to lying about what H does?

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

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

 copy mid

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

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

On 5/21/22 9:02 PM, olcott wrote:
> On 5/21/2022 7:55 PM, Richard Damon wrote:
>> On 5/21/22 3:12 PM, olcott wrote:
>>> On 5/21/2022 2:06 PM, Richard Damon wrote:
>>>> On 5/21/22 3:01 PM, olcott wrote:
>>>>> On 5/21/2022 1:58 PM, Richard Damon wrote:
>>>>>> On 5/21/22 12:47 PM, olcott wrote:
>>>>>>> On 5/21/2022 11:38 AM, Richard Damon wrote:
>>>>>>>> On 5/21/22 12:28 PM, olcott wrote:
>>>>>>>>> On 5/21/2022 11:22 AM, Richard Damon wrote:
>>>>>>>>>> On 5/21/22 11:47 AM, olcott wrote:
>>>>>>>>>>> On 5/21/2022 10:14 AM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 5/21/22 10:44 AM, olcott wrote:
>>>>>>>>>>>>> It is an easily verified fact that the execution trace
>>>>>>>>>>>>> provided by H(P,P) of the nested simulation of its input
>>>>>>>>>>>>> exactly matches the behavior of the correctly
>>>>>>>>>>>>> reverse-engineered nested execution trace would be.
>>>>>>>>>>>>
>>>>>>>>>>>> No, it is easy to verify that it does NOT.
>>>>>>>>>>> You know that you are a liar so I challenge you to provide
>>>>>>>>>>> the execution trace that a pure single level nested emulation
>>>>>>>>>>> of the input to H(P,P) would be. Any failure to provide this
>>>>>>>>>>> basis for your damned lies will be considered direct
>>>>>>>>>>> admission that you know you are lying.
>>>>>>>>>>>
>>>>>>>>>>> _P()
>>>>>>>>>>> [00001352](01)  55              push ebp
>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp
>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>>>> [00001358](01)  50              push eax      // push P
>>>>>>>>>>> [00001359](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>>>> [0000135c](01)  51              push ecx      // push P
>>>>>>>>>>> [0000135d](05)  e840feffff      call 000011a2 // call H
>>>>>>>>>>> [00001362](03)  83c408          add esp,+08
>>>>>>>>>>> [00001365](02)  85c0            test eax,eax
>>>>>>>>>>> [00001367](02)  7402            jz 0000136b
>>>>>>>>>>> [00001369](02)  ebfe            jmp 00001369
>>>>>>>>>>> [0000136b](01)  5d              pop ebp
>>>>>>>>>>> [0000136c](01)  c3              ret
>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Well, I wopuld need to have the code for H to do that, since
>>>>>>>>>> that is PART of P.
>>>>>>>>>>
>>>>>>>>>> It would begin as:
>>>>>>>>>>
>>>>>>>>>>      machine   stack     stack     machine    assembly
>>>>>>>>>>      address   address   data      code       language
>>>>>>>>>>      ========  ========  ========  =========  =============
>>>>>>>>>> ...[00001352][0021233e][00212342] 55         push ebp      //
>>>>>>>>>> enter P
>>>>>>>>>> ...[00001353][0021233e][00212342] 8bec       mov ebp,esp
>>>>>>>>>> ...[00001355][0021233e][00212342] 8b4508     mov eax,[ebp+08]
>>>>>>>>>> ...[00001358][0021233a][00001352] 50         push eax      //
>>>>>>>>>> push P
>>>>>>>>>> ...[00001359][0021233a][00001352] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>> ...[0000135c][00212336][00001352] 51         push ecx      //
>>>>>>>>>> push P
>>>>>>>>>> ...[0000135d][00212332][00001362] e840feffff call 000011a2 //
>>>>>>>>>> call H
>>>>>>>>>>
>>>>>>>>>> At this point I don't have the data,
>>>>>>>>>
>>>>>>>>> The assumption is that H(P,P) correctly emulates its input.
>>>>>>>>
>>>>>>>> Maybe a bad assumption!
>>>>>>>>
>>>>>>>
>>>>>>> It is stipulated that you must show what the execution trace of
>>>>>>> the input to H(P,P) would be if H only simulated its input. You
>>>>>>> must show this for one simulation and one nested simulation.
>>>>>>> Failure to do this will be construed as a direct admission that
>>>>>>> you know you are lying.
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> So, give me a copy of H to trace,
>>>>> You are required to provide a trace under the assumption that
>>>>> H(P,P) only does a pure x86 emulation of its input for the first
>>>>> emulation and the first nested emulation. Are you too stupid to
>>>>> understand this?
>>>>>
>>>>
>>>> You obviously have an reading problem.
>>>>
>>>> I said, for that I need the code of H, as that is what needs to be
>>>> traced.
>>>>
>>>
>>> If it is "given" that this code only performs a pure x86 emulation of
>>> its input (unless you have no idea what an x86 emulation is) there is
>>> no reason to see that the code derives a pure x86 emulation of its
>>> input.
>>
>> The the trace of the emulation needs to show the actual steps of
>> emulationg the input, like I mentioned.
>>
> If I showed either the source-code of H or the execution trace of H
> people here would be so confused that I would never reach closure in 50
> years. If they can't comprehend a 14 line execution trace then showing
> them much more than this would permanently scramble their brains.

No, people wouldn't be confused,

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

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

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

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

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

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

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

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

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

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

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

<I6idnSPl8NebDBT_nZ2dnUU7_81g4p2d@giganews.com>

 copy mid

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

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

On 5/21/2022 8:16 PM, Richard Damon wrote:
> On 5/21/22 9:02 PM, olcott wrote:
>> On 5/21/2022 7:55 PM, Richard Damon wrote:
>>> On 5/21/22 3:12 PM, olcott wrote:
>>>> On 5/21/2022 2:06 PM, Richard Damon wrote:
>>>>> On 5/21/22 3:01 PM, olcott wrote:
>>>>>> On 5/21/2022 1:58 PM, Richard Damon wrote:
>>>>>>> On 5/21/22 12:47 PM, olcott wrote:
>>>>>>>> On 5/21/2022 11:38 AM, Richard Damon wrote:
>>>>>>>>> On 5/21/22 12:28 PM, olcott wrote:
>>>>>>>>>> On 5/21/2022 11:22 AM, Richard Damon wrote:
>>>>>>>>>>> On 5/21/22 11:47 AM, olcott wrote:
>>>>>>>>>>>> On 5/21/2022 10:14 AM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 5/21/22 10:44 AM, olcott wrote:
>>>>>>>>>>>>>> It is an easily verified fact that the execution trace
>>>>>>>>>>>>>> provided by H(P,P) of the nested simulation of its input
>>>>>>>>>>>>>> exactly matches the behavior of the correctly
>>>>>>>>>>>>>> reverse-engineered nested execution trace would be.
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, it is easy to verify that it does NOT.
>>>>>>>>>>>> You know that you are a liar so I challenge you to provide
>>>>>>>>>>>> the execution trace that a pure single level nested
>>>>>>>>>>>> emulation of the input to H(P,P) would be. Any failure to
>>>>>>>>>>>> provide this basis for your damned lies will be considered
>>>>>>>>>>>> direct admission that you know you are lying.
>>>>>>>>>>>>
>>>>>>>>>>>> _P()
>>>>>>>>>>>> [00001352](01)  55              push ebp
>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp
>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>>>>> [00001358](01)  50              push eax      // push P
>>>>>>>>>>>> [00001359](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>>>>> [0000135c](01)  51              push ecx      // push P
>>>>>>>>>>>> [0000135d](05)  e840feffff      call 000011a2 // call H
>>>>>>>>>>>> [00001362](03)  83c408          add esp,+08
>>>>>>>>>>>> [00001365](02)  85c0            test eax,eax
>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b
>>>>>>>>>>>> [00001369](02)  ebfe            jmp 00001369
>>>>>>>>>>>> [0000136b](01)  5d              pop ebp
>>>>>>>>>>>> [0000136c](01)  c3              ret
>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Well, I wopuld need to have the code for H to do that, since
>>>>>>>>>>> that is PART of P.
>>>>>>>>>>>
>>>>>>>>>>> It would begin as:
>>>>>>>>>>>
>>>>>>>>>>>      machine   stack     stack     machine    assembly
>>>>>>>>>>>      address   address   data      code       language
>>>>>>>>>>>      ========  ========  ========  =========  =============
>>>>>>>>>>> ...[00001352][0021233e][00212342] 55         push ebp      //
>>>>>>>>>>> enter P
>>>>>>>>>>> ...[00001353][0021233e][00212342] 8bec       mov ebp,esp
>>>>>>>>>>> ...[00001355][0021233e][00212342] 8b4508     mov eax,[ebp+08]
>>>>>>>>>>> ...[00001358][0021233a][00001352] 50         push eax      //
>>>>>>>>>>> push P
>>>>>>>>>>> ...[00001359][0021233a][00001352] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>>> ...[0000135c][00212336][00001352] 51         push ecx      //
>>>>>>>>>>> push P
>>>>>>>>>>> ...[0000135d][00212332][00001362] e840feffff call 000011a2 //
>>>>>>>>>>> call H
>>>>>>>>>>>
>>>>>>>>>>> At this point I don't have the data,
>>>>>>>>>>
>>>>>>>>>> The assumption is that H(P,P) correctly emulates its input.
>>>>>>>>>
>>>>>>>>> Maybe a bad assumption!
>>>>>>>>>
>>>>>>>>
>>>>>>>> It is stipulated that you must show what the execution trace of
>>>>>>>> the input to H(P,P) would be if H only simulated its input. You
>>>>>>>> must show this for one simulation and one nested simulation.
>>>>>>>> Failure to do this will be construed as a direct admission that
>>>>>>>> you know you are lying.
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> So, give me a copy of H to trace,
>>>>>> You are required to provide a trace under the assumption that
>>>>>> H(P,P) only does a pure x86 emulation of its input for the first
>>>>>> emulation and the first nested emulation. Are you too stupid to
>>>>>> understand this?
>>>>>>
>>>>>
>>>>> You obviously have an reading problem.
>>>>>
>>>>> I said, for that I need the code of H, as that is what needs to be
>>>>> traced.
>>>>>
>>>>
>>>> If it is "given" that this code only performs a pure x86 emulation
>>>> of its input (unless you have no idea what an x86 emulation is)
>>>> there is no reason to see that the code derives a pure x86 emulation
>>>> of its input.
>>>
>>> The the trace of the emulation needs to show the actual steps of
>>> emulationg the input, like I mentioned.
>>>
>> If I showed either the source-code of H or the execution trace of H
>> people here would be so confused that I would never reach closure in
>> 50 years. If they can't comprehend a 14 line execution trace then
>> showing them much more than this would permanently scramble their brains.
>
> No, people wouldn't be confused,
>

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

--
Copyright 2022 Pete Olcott

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

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

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

 copy mid

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

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

On 5/21/22 9:25 PM, olcott wrote:
> On 5/21/2022 8:16 PM, Richard Damon wrote:
>> On 5/21/22 9:02 PM, olcott wrote:
>>> On 5/21/2022 7:55 PM, Richard Damon wrote:
>>>> On 5/21/22 3:12 PM, olcott wrote:
>>>>> On 5/21/2022 2:06 PM, Richard Damon wrote:
>>>>>> On 5/21/22 3:01 PM, olcott wrote:
>>>>>>> On 5/21/2022 1:58 PM, Richard Damon wrote:
>>>>>>>> On 5/21/22 12:47 PM, olcott wrote:
>>>>>>>>> On 5/21/2022 11:38 AM, Richard Damon wrote:
>>>>>>>>>> On 5/21/22 12:28 PM, olcott wrote:
>>>>>>>>>>> On 5/21/2022 11:22 AM, Richard Damon wrote:
>>>>>>>>>>>> On 5/21/22 11:47 AM, olcott wrote:
>>>>>>>>>>>>> On 5/21/2022 10:14 AM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 5/21/22 10:44 AM, olcott wrote:
>>>>>>>>>>>>>>> It is an easily verified fact that the execution trace
>>>>>>>>>>>>>>> provided by H(P,P) of the nested simulation of its input
>>>>>>>>>>>>>>> exactly matches the behavior of the correctly
>>>>>>>>>>>>>>> reverse-engineered nested execution trace would be.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, it is easy to verify that it does NOT.
>>>>>>>>>>>>> You know that you are a liar so I challenge you to provide
>>>>>>>>>>>>> the execution trace that a pure single level nested
>>>>>>>>>>>>> emulation of the input to H(P,P) would be. Any failure to
>>>>>>>>>>>>> provide this basis for your damned lies will be considered
>>>>>>>>>>>>> direct admission that you know you are lying.
>>>>>>>>>>>>>
>>>>>>>>>>>>> _P()
>>>>>>>>>>>>> [00001352](01)  55              push ebp
>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp
>>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>>>>>> [00001358](01)  50              push eax      // push P
>>>>>>>>>>>>> [00001359](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>>>>>> [0000135c](01)  51              push ecx      // push P
>>>>>>>>>>>>> [0000135d](05)  e840feffff      call 000011a2 // call H
>>>>>>>>>>>>> [00001362](03)  83c408          add esp,+08
>>>>>>>>>>>>> [00001365](02)  85c0            test eax,eax
>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b
>>>>>>>>>>>>> [00001369](02)  ebfe            jmp 00001369
>>>>>>>>>>>>> [0000136b](01)  5d              pop ebp
>>>>>>>>>>>>> [0000136c](01)  c3              ret
>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Well, I wopuld need to have the code for H to do that, since
>>>>>>>>>>>> that is PART of P.
>>>>>>>>>>>>
>>>>>>>>>>>> It would begin as:
>>>>>>>>>>>>
>>>>>>>>>>>>      machine   stack     stack     machine    assembly
>>>>>>>>>>>>      address   address   data      code       language
>>>>>>>>>>>>      ========  ========  ========  =========  =============
>>>>>>>>>>>> ...[00001352][0021233e][00212342] 55         push ebp
>>>>>>>>>>>> // enter P
>>>>>>>>>>>> ...[00001353][0021233e][00212342] 8bec       mov ebp,esp
>>>>>>>>>>>> ...[00001355][0021233e][00212342] 8b4508     mov eax,[ebp+08]
>>>>>>>>>>>> ...[00001358][0021233a][00001352] 50         push eax
>>>>>>>>>>>> // push P
>>>>>>>>>>>> ...[00001359][0021233a][00001352] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>>>> ...[0000135c][00212336][00001352] 51         push ecx
>>>>>>>>>>>> // push P
>>>>>>>>>>>> ...[0000135d][00212332][00001362] e840feffff call 000011a2
>>>>>>>>>>>> // call H
>>>>>>>>>>>>
>>>>>>>>>>>> At this point I don't have the data,
>>>>>>>>>>>
>>>>>>>>>>> The assumption is that H(P,P) correctly emulates its input.
>>>>>>>>>>
>>>>>>>>>> Maybe a bad assumption!
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is stipulated that you must show what the execution trace of
>>>>>>>>> the input to H(P,P) would be if H only simulated its input. You
>>>>>>>>> must show this for one simulation and one nested simulation.
>>>>>>>>> Failure to do this will be construed as a direct admission that
>>>>>>>>> you know you are lying.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> So, give me a copy of H to trace,
>>>>>>> You are required to provide a trace under the assumption that
>>>>>>> H(P,P) only does a pure x86 emulation of its input for the first
>>>>>>> emulation and the first nested emulation. Are you too stupid to
>>>>>>> understand this?
>>>>>>>
>>>>>>
>>>>>> You obviously have an reading problem.
>>>>>>
>>>>>> I said, for that I need the code of H, as that is what needs to be
>>>>>> traced.
>>>>>>
>>>>>
>>>>> If it is "given" that this code only performs a pure x86 emulation
>>>>> of its input (unless you have no idea what an x86 emulation is)
>>>>> there is no reason to see that the code derives a pure x86
>>>>> emulation of its input.
>>>>
>>>> The the trace of the emulation needs to show the actual steps of
>>>> emulationg the input, like I mentioned.
>>>>
>>> If I showed either the source-code of H or the execution trace of H
>>> people here would be so confused that I would never reach closure in
>>> 50 years. If they can't comprehend a 14 line execution trace then
>>> showing them much more than this would permanently scramble their
>>> brains.
>>
>> No, people wouldn't be confused,
>>
>
> That they don't understand that they don't need to see this conclusively
> proves that they have woefully inadequate technical skills to evaluate
> my work.
>

Just shows you are lying.

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

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

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


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

<ZMadnSNEEuKCPBT_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

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

On 5/21/2022 9:27 PM, Richard Damon wrote:
> On 5/21/22 9:25 PM, olcott wrote:
>> On 5/21/2022 8:16 PM, Richard Damon wrote:
>>> On 5/21/22 9:02 PM, olcott wrote:
>>>> On 5/21/2022 7:55 PM, Richard Damon wrote:
>>>>> On 5/21/22 3:12 PM, olcott wrote:
>>>>>> On 5/21/2022 2:06 PM, Richard Damon wrote:
>>>>>>> On 5/21/22 3:01 PM, olcott wrote:
>>>>>>>> On 5/21/2022 1:58 PM, Richard Damon wrote:
>>>>>>>>> On 5/21/22 12:47 PM, olcott wrote:
>>>>>>>>>> On 5/21/2022 11:38 AM, Richard Damon wrote:
>>>>>>>>>>> On 5/21/22 12:28 PM, olcott wrote:
>>>>>>>>>>>> On 5/21/2022 11:22 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 5/21/22 11:47 AM, olcott wrote:
>>>>>>>>>>>>>> On 5/21/2022 10:14 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 5/21/22 10:44 AM, olcott wrote:
>>>>>>>>>>>>>>>> It is an easily verified fact that the execution trace
>>>>>>>>>>>>>>>> provided by H(P,P) of the nested simulation of its input
>>>>>>>>>>>>>>>> exactly matches the behavior of the correctly
>>>>>>>>>>>>>>>> reverse-engineered nested execution trace would be.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, it is easy to verify that it does NOT.
>>>>>>>>>>>>>> You know that you are a liar so I challenge you to provide
>>>>>>>>>>>>>> the execution trace that a pure single level nested
>>>>>>>>>>>>>> emulation of the input to H(P,P) would be. Any failure to
>>>>>>>>>>>>>> provide this basis for your damned lies will be considered
>>>>>>>>>>>>>> direct admission that you know you are lying.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>> [00001352](01)  55              push ebp
>>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>>>>>>> [00001358](01)  50              push eax      // push P
>>>>>>>>>>>>>> [00001359](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>>>>>>> [0000135c](01)  51              push ecx      // push P
>>>>>>>>>>>>>> [0000135d](05)  e840feffff      call 000011a2 // call H
>>>>>>>>>>>>>> [00001362](03)  83c408          add esp,+08
>>>>>>>>>>>>>> [00001365](02)  85c0            test eax,eax
>>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b
>>>>>>>>>>>>>> [00001369](02)  ebfe            jmp 00001369
>>>>>>>>>>>>>> [0000136b](01)  5d              pop ebp
>>>>>>>>>>>>>> [0000136c](01)  c3              ret
>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Well, I wopuld need to have the code for H to do that,
>>>>>>>>>>>>> since that is PART of P.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It would begin as:
>>>>>>>>>>>>>
>>>>>>>>>>>>>      machine   stack     stack     machine    assembly
>>>>>>>>>>>>>      address   address   data      code       language
>>>>>>>>>>>>>      ========  ========  ========  =========  =============
>>>>>>>>>>>>> ...[00001352][0021233e][00212342] 55         push ebp //
>>>>>>>>>>>>> enter P
>>>>>>>>>>>>> ...[00001353][0021233e][00212342] 8bec       mov ebp,esp
>>>>>>>>>>>>> ...[00001355][0021233e][00212342] 8b4508     mov eax,[ebp+08]
>>>>>>>>>>>>> ...[00001358][0021233a][00001352] 50         push eax //
>>>>>>>>>>>>> push P
>>>>>>>>>>>>> ...[00001359][0021233a][00001352] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>>>>> ...[0000135c][00212336][00001352] 51         push ecx //
>>>>>>>>>>>>> push P
>>>>>>>>>>>>> ...[0000135d][00212332][00001362] e840feffff call 000011a2
>>>>>>>>>>>>> // call H
>>>>>>>>>>>>>
>>>>>>>>>>>>> At this point I don't have the data,
>>>>>>>>>>>>
>>>>>>>>>>>> The assumption is that H(P,P) correctly emulates its input.
>>>>>>>>>>>
>>>>>>>>>>> Maybe a bad assumption!
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is stipulated that you must show what the execution trace
>>>>>>>>>> of the input to H(P,P) would be if H only simulated its input.
>>>>>>>>>> You must show this for one simulation and one nested
>>>>>>>>>> simulation. Failure to do this will be construed as a direct
>>>>>>>>>> admission that you know you are lying.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So, give me a copy of H to trace,
>>>>>>>> You are required to provide a trace under the assumption that
>>>>>>>> H(P,P) only does a pure x86 emulation of its input for the first
>>>>>>>> emulation and the first nested emulation. Are you too stupid to
>>>>>>>> understand this?
>>>>>>>>
>>>>>>>
>>>>>>> You obviously have an reading problem.
>>>>>>>
>>>>>>> I said, for that I need the code of H, as that is what needs to
>>>>>>> be traced.
>>>>>>>
>>>>>>
>>>>>> If it is "given" that this code only performs a pure x86 emulation
>>>>>> of its input (unless you have no idea what an x86 emulation is)
>>>>>> there is no reason to see that the code derives a pure x86
>>>>>> emulation of its input.
>>>>>
>>>>> The the trace of the emulation needs to show the actual steps of
>>>>> emulationg the input, like I mentioned.
>>>>>
>>>> If I showed either the source-code of H or the execution trace of H
>>>> people here would be so confused that I would never reach closure in
>>>> 50 years. If they can't comprehend a 14 line execution trace then
>>>> showing them much more than this would permanently scramble their
>>>> brains.
>>>
>>> No, people wouldn't be confused,
>>>
>>
>> That they don't understand that they don't need to see this
>> conclusively proves that they have woefully inadequate technical
>> skills to evaluate my work.
>>
>
> Just shows you are lying.
>
I coined the term "ignorance squared" decades ago to account for the
fact that people cannot possibly be directly aware of their own ignorance.


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

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

 copy mid

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

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

On 5/21/22 10:34 PM, olcott wrote:
> On 5/21/2022 9:27 PM, Richard Damon wrote:
>> On 5/21/22 9:25 PM, olcott wrote:
>>> On 5/21/2022 8:16 PM, Richard Damon wrote:
>>>> On 5/21/22 9:02 PM, olcott wrote:
>>>>> On 5/21/2022 7:55 PM, Richard Damon wrote:
>>>>>> On 5/21/22 3:12 PM, olcott wrote:
>>>>>>> On 5/21/2022 2:06 PM, Richard Damon wrote:
>>>>>>>> On 5/21/22 3:01 PM, olcott wrote:
>>>>>>>>> On 5/21/2022 1:58 PM, Richard Damon wrote:
>>>>>>>>>> On 5/21/22 12:47 PM, olcott wrote:
>>>>>>>>>>> On 5/21/2022 11:38 AM, Richard Damon wrote:
>>>>>>>>>>>> On 5/21/22 12:28 PM, olcott wrote:
>>>>>>>>>>>>> On 5/21/2022 11:22 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 5/21/22 11:47 AM, olcott wrote:
>>>>>>>>>>>>>>> On 5/21/2022 10:14 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 5/21/22 10:44 AM, olcott wrote:
>>>>>>>>>>>>>>>>> It is an easily verified fact that the execution trace
>>>>>>>>>>>>>>>>> provided by H(P,P) of the nested simulation of its
>>>>>>>>>>>>>>>>> input exactly matches the behavior of the correctly
>>>>>>>>>>>>>>>>> reverse-engineered nested execution trace would be.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, it is easy to verify that it does NOT.
>>>>>>>>>>>>>>> You know that you are a liar so I challenge you to
>>>>>>>>>>>>>>> provide the execution trace that a pure single level
>>>>>>>>>>>>>>> nested emulation of the input to H(P,P) would be. Any
>>>>>>>>>>>>>>> failure to provide this basis for your damned lies will
>>>>>>>>>>>>>>> be considered direct admission that you know you are lying.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>> [00001352](01)  55              push ebp
>>>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>>>>>>>> [00001358](01)  50              push eax      // push P
>>>>>>>>>>>>>>> [00001359](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>>>>>>>> [0000135c](01)  51              push ecx      // push P
>>>>>>>>>>>>>>> [0000135d](05)  e840feffff      call 000011a2 // call H
>>>>>>>>>>>>>>> [00001362](03)  83c408          add esp,+08
>>>>>>>>>>>>>>> [00001365](02)  85c0            test eax,eax
>>>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b
>>>>>>>>>>>>>>> [00001369](02)  ebfe            jmp 00001369
>>>>>>>>>>>>>>> [0000136b](01)  5d              pop ebp
>>>>>>>>>>>>>>> [0000136c](01)  c3              ret
>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Well, I wopuld need to have the code for H to do that,
>>>>>>>>>>>>>> since that is PART of P.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It would begin as:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>      machine   stack     stack     machine    assembly
>>>>>>>>>>>>>>      address   address   data      code       language
>>>>>>>>>>>>>>      ========  ========  ========  =========  =============
>>>>>>>>>>>>>> ...[00001352][0021233e][00212342] 55         push ebp //
>>>>>>>>>>>>>> enter P
>>>>>>>>>>>>>> ...[00001353][0021233e][00212342] 8bec       mov ebp,esp
>>>>>>>>>>>>>> ...[00001355][0021233e][00212342] 8b4508     mov eax,[ebp+08]
>>>>>>>>>>>>>> ...[00001358][0021233a][00001352] 50         push eax //
>>>>>>>>>>>>>> push P
>>>>>>>>>>>>>> ...[00001359][0021233a][00001352] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>>>>>> ...[0000135c][00212336][00001352] 51         push ecx //
>>>>>>>>>>>>>> push P
>>>>>>>>>>>>>> ...[0000135d][00212332][00001362] e840feffff call 000011a2
>>>>>>>>>>>>>> // call H
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> At this point I don't have the data,
>>>>>>>>>>>>>
>>>>>>>>>>>>> The assumption is that H(P,P) correctly emulates its input.
>>>>>>>>>>>>
>>>>>>>>>>>> Maybe a bad assumption!
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It is stipulated that you must show what the execution trace
>>>>>>>>>>> of the input to H(P,P) would be if H only simulated its
>>>>>>>>>>> input. You must show this for one simulation and one nested
>>>>>>>>>>> simulation. Failure to do this will be construed as a direct
>>>>>>>>>>> admission that you know you are lying.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> So, give me a copy of H to trace,
>>>>>>>>> You are required to provide a trace under the assumption that
>>>>>>>>> H(P,P) only does a pure x86 emulation of its input for the
>>>>>>>>> first emulation and the first nested emulation. Are you too
>>>>>>>>> stupid to understand this?
>>>>>>>>>
>>>>>>>>
>>>>>>>> You obviously have an reading problem.
>>>>>>>>
>>>>>>>> I said, for that I need the code of H, as that is what needs to
>>>>>>>> be traced.
>>>>>>>>
>>>>>>>
>>>>>>> If it is "given" that this code only performs a pure x86
>>>>>>> emulation of its input (unless you have no idea what an x86
>>>>>>> emulation is) there is no reason to see that the code derives a
>>>>>>> pure x86 emulation of its input.
>>>>>>
>>>>>> The the trace of the emulation needs to show the actual steps of
>>>>>> emulationg the input, like I mentioned.
>>>>>>
>>>>> If I showed either the source-code of H or the execution trace of H
>>>>> people here would be so confused that I would never reach closure
>>>>> in 50 years. If they can't comprehend a 14 line execution trace
>>>>> then showing them much more than this would permanently scramble
>>>>> their brains.
>>>>
>>>> No, people wouldn't be confused,
>>>>
>>>
>>> That they don't understand that they don't need to see this
>>> conclusively proves that they have woefully inadequate technical
>>> skills to evaluate my work.
>>>
>>
>> Just shows you are lying.
>>
> I coined the term "ignorance squared" decades ago to account for the
> fact that people cannot possibly be directly aware of their own ignorance.


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

<EomdnXF6lJd_MRT_nZ2dnUU7_81g4p2d@giganews.com>

 copy mid

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

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

On 5/21/2022 10:12 PM, Richard Damon wrote:
> On 5/21/22 10:34 PM, olcott wrote:
>> On 5/21/2022 9:27 PM, Richard Damon wrote:
>>> On 5/21/22 9:25 PM, olcott wrote:
>>>> On 5/21/2022 8:16 PM, Richard Damon wrote:
>>>>> On 5/21/22 9:02 PM, olcott wrote:
>>>>>> On 5/21/2022 7:55 PM, Richard Damon wrote:
>>>>>>> On 5/21/22 3:12 PM, olcott wrote:
>>>>>>>> On 5/21/2022 2:06 PM, Richard Damon wrote:
>>>>>>>>> On 5/21/22 3:01 PM, olcott wrote:
>>>>>>>>>> On 5/21/2022 1:58 PM, Richard Damon wrote:
>>>>>>>>>>> On 5/21/22 12:47 PM, olcott wrote:
>>>>>>>>>>>> On 5/21/2022 11:38 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 5/21/22 12:28 PM, olcott wrote:
>>>>>>>>>>>>>> On 5/21/2022 11:22 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 5/21/22 11:47 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 5/21/2022 10:14 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 5/21/22 10:44 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> It is an easily verified fact that the execution trace
>>>>>>>>>>>>>>>>>> provided by H(P,P) of the nested simulation of its
>>>>>>>>>>>>>>>>>> input exactly matches the behavior of the correctly
>>>>>>>>>>>>>>>>>> reverse-engineered nested execution trace would be.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, it is easy to verify that it does NOT.
>>>>>>>>>>>>>>>> You know that you are a liar so I challenge you to
>>>>>>>>>>>>>>>> provide the execution trace that a pure single level
>>>>>>>>>>>>>>>> nested emulation of the input to H(P,P) would be. Any
>>>>>>>>>>>>>>>> failure to provide this basis for your damned lies will
>>>>>>>>>>>>>>>> be considered direct admission that you know you are lying.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>> [00001352](01)  55              push ebp
>>>>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>>>>>>>>> [00001358](01)  50              push eax      // push P
>>>>>>>>>>>>>>>> [00001359](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>>>>>>>>> [0000135c](01)  51              push ecx      // push P
>>>>>>>>>>>>>>>> [0000135d](05)  e840feffff      call 000011a2 // call H
>>>>>>>>>>>>>>>> [00001362](03)  83c408          add esp,+08
>>>>>>>>>>>>>>>> [00001365](02)  85c0            test eax,eax
>>>>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b
>>>>>>>>>>>>>>>> [00001369](02)  ebfe            jmp 00001369
>>>>>>>>>>>>>>>> [0000136b](01)  5d              pop ebp
>>>>>>>>>>>>>>>> [0000136c](01)  c3              ret
>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Well, I wopuld need to have the code for H to do that,
>>>>>>>>>>>>>>> since that is PART of P.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It would begin as:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>      machine   stack     stack     machine    assembly
>>>>>>>>>>>>>>>      address   address   data      code       language
>>>>>>>>>>>>>>>      ========  ========  ========  =========  =============
>>>>>>>>>>>>>>> ...[00001352][0021233e][00212342] 55         push ebp //
>>>>>>>>>>>>>>> enter P
>>>>>>>>>>>>>>> ...[00001353][0021233e][00212342] 8bec       mov ebp,esp
>>>>>>>>>>>>>>> ...[00001355][0021233e][00212342] 8b4508     mov
>>>>>>>>>>>>>>> eax,[ebp+08]
>>>>>>>>>>>>>>> ...[00001358][0021233a][00001352] 50         push eax //
>>>>>>>>>>>>>>> push P
>>>>>>>>>>>>>>> ...[00001359][0021233a][00001352] 8b4d08     mov
>>>>>>>>>>>>>>> ecx,[ebp+08]
>>>>>>>>>>>>>>> ...[0000135c][00212336][00001352] 51         push ecx //
>>>>>>>>>>>>>>> push P
>>>>>>>>>>>>>>> ...[0000135d][00212332][00001362] e840feffff call
>>>>>>>>>>>>>>> 000011a2 // call H
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> At this point I don't have the data,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The assumption is that H(P,P) correctly emulates its input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Maybe a bad assumption!
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> It is stipulated that you must show what the execution trace
>>>>>>>>>>>> of the input to H(P,P) would be if H only simulated its
>>>>>>>>>>>> input. You must show this for one simulation and one nested
>>>>>>>>>>>> simulation. Failure to do this will be construed as a direct
>>>>>>>>>>>> admission that you know you are lying.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> So, give me a copy of H to trace,
>>>>>>>>>> You are required to provide a trace under the assumption that
>>>>>>>>>> H(P,P) only does a pure x86 emulation of its input for the
>>>>>>>>>> first emulation and the first nested emulation. Are you too
>>>>>>>>>> stupid to understand this?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You obviously have an reading problem.
>>>>>>>>>
>>>>>>>>> I said, for that I need the code of H, as that is what needs to
>>>>>>>>> be traced.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If it is "given" that this code only performs a pure x86
>>>>>>>> emulation of its input (unless you have no idea what an x86
>>>>>>>> emulation is) there is no reason to see that the code derives a
>>>>>>>> pure x86 emulation of its input.
>>>>>>>
>>>>>>> The the trace of the emulation needs to show the actual steps of
>>>>>>> emulationg the input, like I mentioned.
>>>>>>>
>>>>>> If I showed either the source-code of H or the execution trace of
>>>>>> H people here would be so confused that I would never reach
>>>>>> closure in 50 years. If they can't comprehend a 14 line execution
>>>>>> trace then showing them much more than this would permanently
>>>>>> scramble their brains.
>>>>>
>>>>> No, people wouldn't be confused,
>>>>>
>>>>
>>>> That they don't understand that they don't need to see this
>>>> conclusively proves that they have woefully inadequate technical
>>>> skills to evaluate my work.
>>>>
>>>
>>> Just shows you are lying.
>>>
>> I coined the term "ignorance squared" decades ago to account for the
>> fact that people cannot possibly be directly aware of their own
>> ignorance.
>
> You seem tobe a good example of that.
>
>>
>> To be directly aware of their own ignorance requires them to contrast
>> their ignorance with the knowledge that they are missing.
>>
>> Since they don't have this missing knowledge they cannot become
>> directly aware that they are missing any knowledge. Their own
>> ignorance is simply perceived as disagreement.
>
> So, what actual FACT do you think I am missing?
That the next level execution trace of the input to H(P,P) must be
identical to the first level trace.


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

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

 copy mid

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

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

On 5/21/22 11:24 PM, olcott wrote:
> On 5/21/2022 10:12 PM, Richard Damon wrote:
>> On 5/21/22 10:34 PM, olcott wrote:
>>> On 5/21/2022 9:27 PM, Richard Damon wrote:
>>>> On 5/21/22 9:25 PM, olcott wrote:
>>>>> On 5/21/2022 8:16 PM, Richard Damon wrote:
>>>>>> On 5/21/22 9:02 PM, olcott wrote:
>>>>>>> On 5/21/2022 7:55 PM, Richard Damon wrote:
>>>>>>>> On 5/21/22 3:12 PM, olcott wrote:
>>>>>>>>> On 5/21/2022 2:06 PM, Richard Damon wrote:
>>>>>>>>>> On 5/21/22 3:01 PM, olcott wrote:
>>>>>>>>>>> On 5/21/2022 1:58 PM, Richard Damon wrote:
>>>>>>>>>>>> On 5/21/22 12:47 PM, olcott wrote:
>>>>>>>>>>>>> On 5/21/2022 11:38 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 5/21/22 12:28 PM, olcott wrote:
>>>>>>>>>>>>>>> On 5/21/2022 11:22 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 5/21/22 11:47 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 5/21/2022 10:14 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 5/21/22 10:44 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> It is an easily verified fact that the execution
>>>>>>>>>>>>>>>>>>> trace provided by H(P,P) of the nested simulation of
>>>>>>>>>>>>>>>>>>> its input exactly matches the behavior of the
>>>>>>>>>>>>>>>>>>> correctly reverse-engineered nested execution trace
>>>>>>>>>>>>>>>>>>> would be.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No, it is easy to verify that it does NOT.
>>>>>>>>>>>>>>>>> You know that you are a liar so I challenge you to
>>>>>>>>>>>>>>>>> provide the execution trace that a pure single level
>>>>>>>>>>>>>>>>> nested emulation of the input to H(P,P) would be. Any
>>>>>>>>>>>>>>>>> failure to provide this basis for your damned lies will
>>>>>>>>>>>>>>>>> be considered direct admission that you know you are
>>>>>>>>>>>>>>>>> lying.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>> [00001352](01)  55              push ebp
>>>>>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>>>>>>>>>> [00001358](01)  50              push eax      // push P
>>>>>>>>>>>>>>>>> [00001359](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>> [0000135c](01)  51              push ecx      // push P
>>>>>>>>>>>>>>>>> [0000135d](05)  e840feffff      call 000011a2 // call H
>>>>>>>>>>>>>>>>> [00001362](03)  83c408          add esp,+08
>>>>>>>>>>>>>>>>> [00001365](02)  85c0            test eax,eax
>>>>>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b
>>>>>>>>>>>>>>>>> [00001369](02)  ebfe            jmp 00001369
>>>>>>>>>>>>>>>>> [0000136b](01)  5d              pop ebp
>>>>>>>>>>>>>>>>> [0000136c](01)  c3              ret
>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Well, I wopuld need to have the code for H to do that,
>>>>>>>>>>>>>>>> since that is PART of P.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It would begin as:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>      machine   stack     stack     machine    assembly
>>>>>>>>>>>>>>>>      address   address   data      code       language
>>>>>>>>>>>>>>>>      ========  ========  ========  =========  =============
>>>>>>>>>>>>>>>> ...[00001352][0021233e][00212342] 55         push ebp //
>>>>>>>>>>>>>>>> enter P
>>>>>>>>>>>>>>>> ...[00001353][0021233e][00212342] 8bec       mov ebp,esp
>>>>>>>>>>>>>>>> ...[00001355][0021233e][00212342] 8b4508     mov
>>>>>>>>>>>>>>>> eax,[ebp+08]
>>>>>>>>>>>>>>>> ...[00001358][0021233a][00001352] 50         push eax //
>>>>>>>>>>>>>>>> push P
>>>>>>>>>>>>>>>> ...[00001359][0021233a][00001352] 8b4d08     mov
>>>>>>>>>>>>>>>> ecx,[ebp+08]
>>>>>>>>>>>>>>>> ...[0000135c][00212336][00001352] 51         push ecx //
>>>>>>>>>>>>>>>> push P
>>>>>>>>>>>>>>>> ...[0000135d][00212332][00001362] e840feffff call
>>>>>>>>>>>>>>>> 000011a2 // call H
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> At this point I don't have the data,
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The assumption is that H(P,P) correctly emulates its input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Maybe a bad assumption!
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is stipulated that you must show what the execution
>>>>>>>>>>>>> trace of the input to H(P,P) would be if H only simulated
>>>>>>>>>>>>> its input. You must show this for one simulation and one
>>>>>>>>>>>>> nested simulation. Failure to do this will be construed as
>>>>>>>>>>>>> a direct admission that you know you are lying.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> So, give me a copy of H to trace,
>>>>>>>>>>> You are required to provide a trace under the assumption that
>>>>>>>>>>> H(P,P) only does a pure x86 emulation of its input for the
>>>>>>>>>>> first emulation and the first nested emulation. Are you too
>>>>>>>>>>> stupid to understand this?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You obviously have an reading problem.
>>>>>>>>>>
>>>>>>>>>> I said, for that I need the code of H, as that is what needs
>>>>>>>>>> to be traced.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If it is "given" that this code only performs a pure x86
>>>>>>>>> emulation of its input (unless you have no idea what an x86
>>>>>>>>> emulation is) there is no reason to see that the code derives a
>>>>>>>>> pure x86 emulation of its input.
>>>>>>>>
>>>>>>>> The the trace of the emulation needs to show the actual steps of
>>>>>>>> emulationg the input, like I mentioned.
>>>>>>>>
>>>>>>> If I showed either the source-code of H or the execution trace of
>>>>>>> H people here would be so confused that I would never reach
>>>>>>> closure in 50 years. If they can't comprehend a 14 line execution
>>>>>>> trace then showing them much more than this would permanently
>>>>>>> scramble their brains.
>>>>>>
>>>>>> No, people wouldn't be confused,
>>>>>>
>>>>>
>>>>> That they don't understand that they don't need to see this
>>>>> conclusively proves that they have woefully inadequate technical
>>>>> skills to evaluate my work.
>>>>>
>>>>
>>>> Just shows you are lying.
>>>>
>>> I coined the term "ignorance squared" decades ago to account for the
>>> fact that people cannot possibly be directly aware of their own
>>> ignorance.
>>
>> You seem tobe a good example of that.
>>
>>>
>>> To be directly aware of their own ignorance requires them to contrast
>>> their ignorance with the knowledge that they are missing.
>>>
>>> Since they don't have this missing knowledge they cannot become
>>> directly aware that they are missing any knowledge. Their own
>>> ignorance is simply perceived as disagreement.
>>
>> So, what actual FACT do you think I am missing?
>  That the next level execution trace of the input to H(P,P) must be
> identical to the first level trace.
>


Click here to read the complete article
Pages:12
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor