Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

A woman should have compassion. -- Kirk, "Catspaw", stardate 3018.2

devel / comp.theory / Re: Here is what a computer scientist that has been published in CACM said about my work [stupid]

SubjectAuthor
* Here is what a computer scientist that has been published in CACMolcott
+* Here is what a computer scientist that has been published inMr Flibble
|`* Here is what a computer scientist that has been published in CACMolcott
| `* Here is what a computer scientist that has been published inMr Flibble
|  `* Here is what a computer scientist that has been published in CACMolcott
|   +* Here is what a computer scientist that has been published inMr Flibble
|   |`* Here is what a computer scientist that has been published in CACMolcott
|   | `* Here is what a computer scientist that has been published inMr Flibble
|   |  `* Here is what a computer scientist that has been published in CACMolcott
|   |   `- Here is what a computer scientist that has been published inMr Flibble
|   `* Here is what a computer scientist that has been published in CACMRichard Damon
|    `* Here is what a computer scientist that has been published in CACMolcott
|     `* Here is what a computer scientist that has been published in CACMRichard Damon
|      `* Here is what a computer scientist that has been published in CACMolcott
|       `* Here is what a computer scientist that has been published in CACMRichard Damon
|        `* Here is what a computer scientist that has been published in CACMolcott
|         `- Here is what a computer scientist that has been published in CACMRichard Damon
+* Here is what a computer scientist that has been published in CACMd thiebaud
|`* Here is what a computer scientist that has been published in CACMolcott
| +* Here is what a computer scientist that has been published inMr Flibble
| |`* Here is what a computer scientist that has been published in CACMolcott
| | `- Here is what a computer scientist that has been published in CACMRichard Damon
| `* Here is what a computer scientist that has been published in CACMSkep Dick
|  `- Here is what a computer scientist that has been published in CACMolcott
+* Here is what a computer scientist that has been published in CACMRichard Harnden
|`- Here is what a computer scientist that has been published in CACMolcott
`* Here is what a computer scientist that has been published inMr Flibble
 `* Here is what a computer scientist that has been published in CACMolcott
  `* Here is what a computer scientist that has been published inMr Flibble
   +* Here is what a computer scientist that has been published inolcott
   |`* Here is what a computer scientist that has been published in CACMRichard Damon
   | `* Here is what a computer scientist that has been published in CACMolcott
   |  `* Here is what a computer scientist that has been published in CACMRichard Damon
   |   `* Here is what a computer scientist that has been published in CACMolcott
   |    `* Here is what a computer scientist that has been published in CACMRichard Damon
   |     `* Here is what a computer scientist that has been published in CACMolcott
   |      `* Here is what a computer scientist that has been published in CACMRichard Damon
   |       `* Here is what a computer scientist that has been published in CACMolcott
   |        `* Here is what a computer scientist that has been published in CACMRichard Damon
   |         `* Here is what a computer scientist that has been published in CACMolcott
   |          `* Here is what a computer scientist that has been published in CACMRichard Damon
   |           `* Here is what a computer scientist that has been published in CACMolcott
   |            `* Here is what a computer scientist that has been published in CACMRichard Damon
   |             `* Here is what a computer scientist that has been published in CACMolcott
   |              `* Here is what a computer scientist that has been published in CACMRichard Damon
   |               `* Here is what a computer scientist that has been published in CACMolcott
   |                `* Here is what a computer scientist that has been published in CACMRichard Damon
   |                 `* Here is what a computer scientist that has been published in CACMolcott
   |                  `* Here is what a computer scientist that has been published in CACMRichard Damon
   |                   `* Here is what a computer scientist that has been published in CACMolcott
   |                    `* Here is what a computer scientist that has been published in CACMRichard Damon
   |                     `* Here is what a computer scientist that has been published in CACMolcott
   |                      `* Here is what a computer scientist that has been published in CACMRichard Damon
   |                       `* Here is what a computer scientist that has been published in CACMolcott
   |                        `* Here is what a computer scientist that has been published in CACMRichard Damon
   |                         +* Here is what a computer scientist that has been published in CACMolcott
   |                         |+- Here is what a computer scientist that has been published in CACMRichard Damon
   |                         |`* Here is what a computer scientist that has been published in CACMSkep Dick
   |                         | +- Here is what a computer scientist that has been published in CACMolcott
   |                         | `* Here is what a computer scientist that has been published in CACMSkep Dick
   |                         |  +* Here is what a computer scientist that has been published in CACMolcott
   |                         |  |`* Here is what a computer scientist that has been published in CACMRichard Damon
   |                         |  | +* Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |`* Here is what a computer scientist that has been published in CACMRichard Damon
   |                         |  | | +* Here is what a computer scientist that has been published in CACMolcott
   |                         |  | | |`- Here is what a computer scientist that has been published in CACMRichard Damon
   |                         |  | | `* Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  +* Here is what a computer scientist that has been published in CACMDennis Bush
   |                         |  | |  |+- Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  |`* Here is what a computer scientist that has been published in CACMDennis Bush
   |                         |  | |  | +- Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  | `* Here is what a computer scientist that has been published in CACMDennis Bush
   |                         |  | |  |  +- Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  |  `* Here is what a computer scientist that has been published in CACMDennis Bush
   |                         |  | |  |   +- Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  |   `* Here is what a computer scientist that has been published in CACMDennis Bush
   |                         |  | |  |    +- Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  |    `* Here is what a computer scientist that has been published in CACMDennis Bush
   |                         |  | |  |     `* Here is what a computer scientist that has been published in CACM said about my olcott
   |                         |  | |  |      `* Here is what a computer scientist that has been published in CACMDennis Bush
   |                         |  | |  |       `* Here is what a computer scientist that has been published in CACM said about my olcott
   |                         |  | |  |        `* Here is what a computer scientist that has been published in CACMDennis Bush
   |                         |  | |  |         +- Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  |         `* Here is what a computer scientist that has been published in CACMDennis Bush
   |                         |  | |  |          +- Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  |          `* Here is what a computer scientist that has been published in CACMDennis Bush
   |                         |  | |  |           +- Here is what a computer scientist that has been published in CACM said about my olcott
   |                         |  | |  |           `* Here is what a computer scientist that has been published in CACMDennis Bush
   |                         |  | |  |            +* Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  |            |`* Here is what a computer scientist that has been published inMr Flibble
   |                         |  | |  |            | `* Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  |            |  `* Here is what a computer scientist that has been published inMr Flibble
   |                         |  | |  |            |   +- Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  |            |   `- Here is what a computer scientist that has been published inMr Flibble
   |                         |  | |  |            +* Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  |            |`* Here is what a computer scientist that has been published inMr Flibble
   |                         |  | |  |            | `* Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  |            |  `* Here is what a computer scientist that has been published inMr Flibble
   |                         |  | |  |            |   `* Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  |            |    `* Here is what a computer scientist that has been published inMr Flibble
   |                         |  | |  |            |     `* Here is what a computer scientist that has been published in CACMolcott
   |                         |  | |  |            +- Here is what a computer scientist that has been published in CACMDennis Bush
   |                         |  | |  |            `- Here is what a computer scientist that has been published in CACMDennis Bush
   |                         |  | |  `* Here is what a computer scientist that has been published in CACMRichard Damon
   |                         |  | `* Here is what a computer scientist that has been published in CACMdklei...@gmail.com
   |                         |  `* Here is what a computer scientist that has been published in CACMSkep Dick
   |                         `* Here is what a computer scientist that has been published in CACMolcott
   `- Here is what a computer scientist that has been published in CACMolcott

Pages:12345678910
Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<tdibk2$dkhr$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: mikko.le...@iki.fi (Mikko)
Newsgroups: comp.theory
Subject: Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]
Date: Wed, 17 Aug 2022 12:15:46 +0300
Organization: -
Lines: 13
Message-ID: <tdibk2$dkhr$1@dont-email.me>
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com> <d2AKK.1016233$X_i.4836@fx18.iad> <t5idnUq6Z-PBRWf_nZ2dnZfqlJzNnZ2d@giganews.com> <3BBKK.730686$5fVf.367715@fx09.iad> <Vp6dnZdlCtCndWf_nZ2dnZfqlJzNnZ2d@giganews.com> <82CKK.917261$JVi.344055@fx17.iad> <V86dnTZgD6Bacmf_nZ2dnZfqlJzNnZ2d@giganews.com> <IGCKK.131460$dh2.119930@fx46.iad> <rf6dne7Bna80ZGf_nZ2dnZfqlJzNnZ2d@giganews.com> <r9DKK.750232$ntj.655539@fx15.iad> <LX-dnT2cwJELnmb_nZ2dnZfqlJ9g4p2d@giganews.com> <JCDKK.772034$ssF.405468@fx14.iad> <19WdnXfCmdUglWb_nZ2dnZfqlJxh4p2d@giganews.com> <tZKKK.773109$ssF.431398@fx14.iad> <3e1e8c27-ec66-4eae-89b0-bd144bb1cd1bn@googlegroups.com> <Z7mdndrO-6onPGb_nZ2dnZfqlJxh4p2d@giganews.com> <f64d20e6-86f3-4f50-a643-e4b6d7fe2ca5n@googlegroups.com> <A46dnW7Luri5NGb_nZ2dnZfqlJ_NnZ2d@giganews.com> <4288ce60-b717-4d4d-910b-1af369173d23n@googlegroups.com> <w-GdnYlep6IBNmb_nZ2dnZfqlJzNnZ2d@giganews.com> <iiXKK.733785$5fVf.180751@fx09.iad> <XJ-dnesKoqyD3mH_nZ2dnZfqlJzNnZ2d@giganews.com>
MIME-Version: 1.0
Content-Type: text/plain; charset=iso-8859-1; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Info: reader01.eternal-september.org; posting-host="8ea66b5711436bb02406ab07d58a92a7";
logging-data="447035"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19Xuf2khYV1J+zPLjWAP/Ob"
User-Agent: Unison/2.2
Cancel-Lock: sha1:n5CUmnlJS6V+tR5huZ4CF4EY3Hg=
 by: Mikko - Wed, 17 Aug 2022 09:15 UTC

On 2022-08-17 01:23:59 +0000, olcott said:

> *Not at all. No one has disproved this statement*
> H(P,P) does correctly predict that its correct and complete x86
> emulation of its input would never stop running, thus does correctly
> reject this input as non-halting.

This is not really a prediction as it is about a sitation that will
never happen. A conterfactual statement does not prove or refute
anything.

Mikko

Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<92857281-cb53-4ddc-908a-50d2937c403en@googlegroups.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
X-Received: by 2002:a05:6214:d07:b0:476:c32f:f4f4 with SMTP id 7-20020a0562140d0700b00476c32ff4f4mr21742454qvh.11.1660736403587;
Wed, 17 Aug 2022 04:40:03 -0700 (PDT)
X-Received: by 2002:a25:7242:0:b0:67c:3179:c678 with SMTP id
n63-20020a257242000000b0067c3179c678mr19172325ybc.345.1660736403377; Wed, 17
Aug 2022 04:40:03 -0700 (PDT)
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Wed, 17 Aug 2022 04:40:03 -0700 (PDT)
In-Reply-To: <h_qdnUg9Jqn282H_nZ2dnZfqlJzNnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=98.110.86.97; posting-account=ejFcQgoAAACAt5i0VbkATkR2ACWdgADD
NNTP-Posting-Host: 98.110.86.97
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<19WdnXfCmdUglWb_nZ2dnZfqlJxh4p2d@giganews.com> <tZKKK.773109$ssF.431398@fx14.iad>
<3e1e8c27-ec66-4eae-89b0-bd144bb1cd1bn@googlegroups.com> <Z7mdndrO-6onPGb_nZ2dnZfqlJxh4p2d@giganews.com>
<f64d20e6-86f3-4f50-a643-e4b6d7fe2ca5n@googlegroups.com> <A46dnW7Luri5NGb_nZ2dnZfqlJ_NnZ2d@giganews.com>
<eeXKK.159378$%i2.92635@fx48.iad> <s0-dnfITQe3_32H_nZ2dnZfqlJ_NnZ2d@giganews.com>
<rUXKK.733786$5fVf.382893@fx09.iad> <tdhir4$astl$1@dont-email.me>
<e669a38a-d240-4a92-aa36-07d3ef57b171n@googlegroups.com> <2uqdnYI1ZK9Zy2H_nZ2dnZfqlJzNnZ2d@giganews.com>
<827c17dc-b5c5-4023-b73c-f77925c56c1an@googlegroups.com> <u8udnaC_csJhwGH_nZ2dnZfqlJxh4p2d@giganews.com>
<cf36a0c8-68d3-4eae-bcc2-39e36c5b1403n@googlegroups.com> <sySdnc8OUfRL_2H_nZ2dnZfqlJ9g4p2d@giganews.com>
<afafbc24-9373-4686-ac19-909a06ffaf79n@googlegroups.com> <c3Sdnf2c2IG_-mH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<2b06c9cb-4cb3-4866-a4ad-a5e9f10a6270n@googlegroups.com> <h_qdnUg9Jqn282H_nZ2dnZfqlJzNnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <92857281-cb53-4ddc-908a-50d2937c403en@googlegroups.com>
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
From: dbush.mo...@gmail.com (Dennis Bush)
Injection-Date: Wed, 17 Aug 2022 11:40:03 +0000
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
X-Received-Bytes: 8036
 by: Dennis Bush - Wed, 17 Aug 2022 11:40 UTC

On Wednesday, August 17, 2022 at 12:28:52 AM UTC-4, olcott wrote:
> On 8/16/2022 11:02 PM, Dennis Bush wrote:
> > On Tuesday, August 16, 2022 at 11:57:51 PM UTC-4, olcott wrote:
> >> On 8/16/2022 10:53 PM, Dennis Bush wrote:
> >>> On Tuesday, August 16, 2022 at 11:39:32 PM UTC-4, olcott wrote:
> >>>> On 8/16/2022 10:23 PM, Dennis Bush wrote:
> >>>>> On Tuesday, August 16, 2022 at 11:18:46 PM UTC-4, olcott wrote:
> >>>>>> On 8/16/2022 9:52 PM, Dennis Bush wrote:
> >>>>>>> On Tuesday, August 16, 2022 at 10:47:57 PM UTC-4, olcott wrote:
> >>>>>>>> On 8/16/2022 9:34 PM, Dennis Bush wrote:
> >>>>>>>>> On Tuesday, August 16, 2022 at 10:12:55 PM UTC-4, olcott wrote:
> >>>>>>>>>> On 8/16/2022 8:55 PM, Richard Damon wrote:
> >>>>>>>>>>> On 8/16/22 9:20 PM, olcott wrote:
> >>>>>>>>>>>> On 8/16/2022 8:10 PM, Richard Damon wrote:
> >>>>>>>>>>>>> On 8/16/22 10:27 AM, olcott wrote:
> >>>>>>>>>>>>>> On 8/16/2022 9:07 AM, Skep Dick wrote:
> >>>>>>>>>>>>>>> On Tuesday, 16 August 2022 at 15:55:30 UTC+2, olcott wrote:
> >>>>>>>>>>>>>>>> The correct and complete x86 emulation of the input to H(P,P) by H
> >>>>>>>>>>>>>>>> WOULD
> >>>>>>>>>>>>>>>> never stop running.
> >>>>>>>>>>>>>>> Sounds like you are stuck in a loop.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Maybe your Decider/Maker should terminate you.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> I have been trying to get an honest person to acknowledge the
> >>>>>>>>>>>>>> correct software engineering of my system so that we can move on to
> >>>>>>>>>>>>>> the next point for a year now. (bot many honest people here, mostly
> >>>>>>>>>>>>>> trolls).
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> The problem is that what you say ISN'T CORRECT software engineering.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> You use the wrong definition of things and incorrect assumptions
> >>>>>>>>>>>>> about thing, so it just isn't true.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> H(P,P) does correctly predict that its correct and complete x86
> >>>>>>>>>>>>>> emulation of its input would never stop running, thus does correctly
> >>>>>>>>>>>>>> reject this input as non-halting.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Nope. And in fact, you even acknoldge it doesn't but just don't see it.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> So you are saying that the correct and complete x86 emulation by
> >>>>>>>>>>>> H(P,P) of its input WOULD STOP RUNNING?
> >>>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> No, I am saying that you H doesn't do a correct and complete emulation
> >>>>>>>>>>> of its input, and thus to say it did is just a LIE.
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> I said that H correctly predicts what the behavior of its correct and
> >>>>>>>>>> complete x86 emulation of H(P,P) would be
> >>>>>>>>>
> >>>>>>>>> The fixed source code of H (and everything it calls) that aborts is Ha. Ha *always* aborts Pa, so "the correct and complete simulation of Ha(Pa,Pa)" does not exist, just like the shoes that Napoleon wore on Mars do not exist.
> >>>>>>>> So you are another brain dead moron the believes it is utterly
> >>>>>>>> impossible for H to correctly predict that its correct and complete x86
> >>>>>>>> emulation of its input would never stop running unless H actually
> >>>>>>>> performed a correct and complete emulation of its input.
> >>>>>>>
> >>>>>>> The correct and complete emulation of Ha(Pa,Pa) doesn't exist,
> >>>>>> Neither does the correct and complete emulation of Infinite_Loop()
> >>>>>
> >>>>> Yes it does. If you simulate Infinite_Loop(), it won't halt. But if you run Ha(Pa,Pa), it won't do a correct and complete simulation because it aborts.
> >>>> When you run H0((u32)Infinite_Loop)
> >>>> "it won't do a correct and complete simulation because it aborts"
> >>>> How long are you going to keep the head game up?
> >>>
> >>> That you don't understand what I'm saying doesn't make it a head game..
> >>>
> >> You reject Ha(Pa,Pa) on this basis
> >> run Ha(Pa,Pa), it won't do a correct and complete simulation because it
> >> aborts.
> >> Yet accept P0(Infinite_Loop), on the same basis
> >> it won't do a correct and complete simulation because it aborts.
> >> ∴ You are playing head games.
> >
> > What does P0 do? Does it abort? If so, then yes P0(Infinite_Loop) doesn't do a correct and complete simulation because it aborts, so it's invalid to predict what the correct and complete simulation of P0(Infinite_Loop) would do.
> >
> > On the other hand, UTM(Infinite_Loop) does do a correct and complete simulation, so it *is* valid to predict what it will do.
> >
> In other words you are not bright enough to see that it is very easy for
> H0 to recognize an infinite loop would never halt in a finite number of
> steps of simulation?

I'm saying that H0 can see that the correct and complete simulation performed by UTM(Infinite_Loop) does not halt. It does not and cannot see that the correct and complete simulation performed by H0(Infinite_Loop) (i.e. your basis for correctness) does not halt because H0 does not perform a correct and complete simulation.

In the same way, Ha does not and cannot see that the correct and complete simulation performed by Ha(Pa,Pa) does not halt because Ha does not perform a correct and complete simulation. As above, what does perform a correct and complete simulation is UTM(Pa,Pa) which does halt, therefore Ha(Pa,Pa)==0 is wrong.

Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<TC4LK.734216$5fVf.250358@fx09.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.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.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<Vp6dnZdlCtCndWf_nZ2dnZfqlJzNnZ2d@giganews.com>
<82CKK.917261$JVi.344055@fx17.iad>
<V86dnTZgD6Bacmf_nZ2dnZfqlJzNnZ2d@giganews.com>
<IGCKK.131460$dh2.119930@fx46.iad>
<rf6dne7Bna80ZGf_nZ2dnZfqlJzNnZ2d@giganews.com>
<r9DKK.750232$ntj.655539@fx15.iad>
<LX-dnT2cwJELnmb_nZ2dnZfqlJ9g4p2d@giganews.com>
<JCDKK.772034$ssF.405468@fx14.iad>
<19WdnXfCmdUglWb_nZ2dnZfqlJxh4p2d@giganews.com>
<tZKKK.773109$ssF.431398@fx14.iad>
<3e1e8c27-ec66-4eae-89b0-bd144bb1cd1bn@googlegroups.com>
<Z7mdndrO-6onPGb_nZ2dnZfqlJxh4p2d@giganews.com>
<f64d20e6-86f3-4f50-a643-e4b6d7fe2ca5n@googlegroups.com>
<A46dnW7Luri5NGb_nZ2dnZfqlJ_NnZ2d@giganews.com>
<eeXKK.159378$%i2.92635@fx48.iad>
<s0-dnfITQe3_32H_nZ2dnZfqlJ_NnZ2d@giganews.com>
<6b3ad507-9de4-4a18-b63d-ad8c0e163ed9n@googlegroups.com>
<b_Kcnf8WbMNH6WH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<fcd6e828-f966-4731-8061-5665a22f970fn@googlegroups.com>
<nLOdnZYR-unTHmH_nZ2dnZfqlJ_NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <nLOdnZYR-unTHmH_nZ2dnZfqlJ_NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 61
Message-ID: <TC4LK.734216$5fVf.250358@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: Wed, 17 Aug 2022 07:51:15 -0400
X-Received-Bytes: 4548
 by: Richard Damon - Wed, 17 Aug 2022 11:51 UTC

On 8/17/22 1:57 AM, olcott wrote:
> On 8/17/2022 12:02 AM, dklei...@gmail.com wrote:
>> On Tuesday, August 16, 2022 at 9:56:23 PM UTC-7, olcott wrote:
>>> On 8/16/2022 11:52 PM, dklei...@gmail.com wrote:
>>>> On Tuesday, August 16, 2022 at 6:21:04 PM UTC-7, olcott wrote:
>>>>>
>>>>> So you are saying that the correct and complete x86 emulation by
>>>>> H(P,P)
>>>>> of its input WOULD STOP RUNNING?
>>>>>
>>>> H is , by definition, a Turing Machine and therefore halts.
>>> H is a C function that I hope to show is a valid proxy for TM at some
>>> future date, after it is accepted that H(P,P)==0 is correct software
>>> engineering.
>>>
>>> I am biding my time here while I am preparing the code for a much wider
>>> audience.
>>>
>> H the C program is assumed equivalent to H the Turing Machine.
>
> H is a C function, not a program and I made it as Turing equivalent as I
> could. H always returns the same value for the same arguments every time
> that it is invoked.

And this is a key part of your error. Computations are much more like
"Programs" then "Functions" in a programming language, as they include
ALL the behavor from invocation to return, not just the behavior inside
the lexical scope of the source code of that particular function.

Thus, the P in P(P) fully includes ALL of H and everything it calls as
part of it. Including its SPECIFIC implementation of any algorithms.

Turing Macnines are ALWAYS the equivalent of a "Program", not an
embedded function.

When you make the Turing Machine Equivalent of P, then that machine, to
be built, includes in it its own copy of the code of H to implment the
call to H.

H, on the other hand, is given the representation of P(P) which it needs
to decide on, in your case starting by simulating it. Note, that since
this input has its own copy of H, your "Address Comparison" trick just
fails to handle this model. Your problem is that Computationally, your H
isn't a complete program by itself, that has an input, but you build a
different program for each input which bundles H and the input together.

You can't create as two totally distinct pieces, an H that matches your
requirements, and a P that can run as a totally seperate program and
also be made the input to H.

>
> The computer scientist seemed to think (this may be a bad paraphrase)
> that H must return the same value for the same arguments EVEN IF H IS
> NOT INVOKED.
>

No, only if it is invoked, but the call H in P, when emulated, needs to
fully behave like all other invocations of that H, as H HAS ben invoked,
even if your simulator hasn't gone into it.

Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<87wnb73wrl.fsf@bsb.me.uk>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader01.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben Bacarisse)
Newsgroups: comp.theory
Subject: Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]
Date: Wed, 17 Aug 2022 13:00:30 +0100
Organization: A noiseless patient Spider
Lines: 25
Message-ID: <87wnb73wrl.fsf@bsb.me.uk>
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<3BBKK.730686$5fVf.367715@fx09.iad>
<Vp6dnZdlCtCndWf_nZ2dnZfqlJzNnZ2d@giganews.com>
<82CKK.917261$JVi.344055@fx17.iad>
<V86dnTZgD6Bacmf_nZ2dnZfqlJzNnZ2d@giganews.com>
<IGCKK.131460$dh2.119930@fx46.iad>
<rf6dne7Bna80ZGf_nZ2dnZfqlJzNnZ2d@giganews.com>
<r9DKK.750232$ntj.655539@fx15.iad>
<LX-dnT2cwJELnmb_nZ2dnZfqlJ9g4p2d@giganews.com>
<JCDKK.772034$ssF.405468@fx14.iad>
<19WdnXfCmdUglWb_nZ2dnZfqlJxh4p2d@giganews.com>
<tZKKK.773109$ssF.431398@fx14.iad>
<3e1e8c27-ec66-4eae-89b0-bd144bb1cd1bn@googlegroups.com>
<Z7mdndrO-6onPGb_nZ2dnZfqlJxh4p2d@giganews.com>
<f64d20e6-86f3-4f50-a643-e4b6d7fe2ca5n@googlegroups.com>
<A46dnW7Luri5NGb_nZ2dnZfqlJ_NnZ2d@giganews.com>
<eeXKK.159378$%i2.92635@fx48.iad>
<s0-dnfITQe3_32H_nZ2dnZfqlJ_NnZ2d@giganews.com>
<6b3ad507-9de4-4a18-b63d-ad8c0e163ed9n@googlegroups.com>
<b_Kcnf8WbMNH6WH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<fcd6e828-f966-4731-8061-5665a22f970fn@googlegroups.com>
MIME-Version: 1.0
Content-Type: text/plain
Injection-Info: reader01.eternal-september.org; posting-host="e9eba11d11c44ea8c13e95dfb596e75b";
logging-data="471035"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19T5ACtU7h2jDq/RTuWWKqbTv0vj0Cunr0="
User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/27.1 (gnu/linux)
Cancel-Lock: sha1:LJ8ouVFUTe/9rG8bf6hf2Z/aDfQ=
sha1:Ba5l5L5s/tZBgRPAvwChjFu/cCs=
X-BSB-Auth: 1.b2c560fd73aa59e2e4f2.20220817130030BST.87wnb73wrl.fsf@bsb.me.uk
 by: Ben Bacarisse - Wed, 17 Aug 2022 12:00 UTC

"dklei...@gmail.com" <dkleinecke@gmail.com> writes:

> On Tuesday, August 16, 2022 at 9:56:23 PM UTC-7, olcott wrote:
>> On 8/16/2022 11:52 PM, dklei...@gmail.com wrote:
>> > On Tuesday, August 16, 2022 at 6:21:04 PM UTC-7, olcott wrote:
>> >>
>> >> So you are saying that the correct and complete x86 emulation by H(P,P)
>> >> of its input WOULD STOP RUNNING?
>> >>
>> > H is , by definition, a Turing Machine and therefore halts.

Did you mean to say that? Perhaps you meant to say that H is, by
definition, a decider and a decider halts regardless of the initial
tape?

(Also, some authors define "a computation" as a finite sequence of TM
configurations so, in that view, all TM computations are, by definition,
halting.)

> H the C program is assumed equivalent to H the Turing Machine.

The same applies when modelling TMs in C.

--
Ben.

Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<7e6dncpnS5v8a2H_nZ2dnZfqlJzNnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border-2.nntp.ord.giganews.com!border-1.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 17 Aug 2022 14:08:33 +0000
Date: Wed, 17 Aug 2022 09:08:50 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<t5idnUq6Z-PBRWf_nZ2dnZfqlJzNnZ2d@giganews.com>
<3BBKK.730686$5fVf.367715@fx09.iad>
<Vp6dnZdlCtCndWf_nZ2dnZfqlJzNnZ2d@giganews.com>
<82CKK.917261$JVi.344055@fx17.iad>
<V86dnTZgD6Bacmf_nZ2dnZfqlJzNnZ2d@giganews.com>
<IGCKK.131460$dh2.119930@fx46.iad>
<rf6dne7Bna80ZGf_nZ2dnZfqlJzNnZ2d@giganews.com>
<r9DKK.750232$ntj.655539@fx15.iad>
<LX-dnT2cwJELnmb_nZ2dnZfqlJ9g4p2d@giganews.com>
<JCDKK.772034$ssF.405468@fx14.iad>
<19WdnXfCmdUglWb_nZ2dnZfqlJxh4p2d@giganews.com>
<tZKKK.773109$ssF.431398@fx14.iad>
<3e1e8c27-ec66-4eae-89b0-bd144bb1cd1bn@googlegroups.com>
<Z7mdndrO-6onPGb_nZ2dnZfqlJxh4p2d@giganews.com>
<f64d20e6-86f3-4f50-a643-e4b6d7fe2ca5n@googlegroups.com>
<A46dnW7Luri5NGb_nZ2dnZfqlJ_NnZ2d@giganews.com>
<4288ce60-b717-4d4d-910b-1af369173d23n@googlegroups.com>
<w-GdnYlep6IBNmb_nZ2dnZfqlJzNnZ2d@giganews.com>
<iiXKK.733785$5fVf.180751@fx09.iad>
<XJ-dnesKoqyD3mH_nZ2dnZfqlJzNnZ2d@giganews.com> <tdibk2$dkhr$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <tdibk2$dkhr$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <7e6dncpnS5v8a2H_nZ2dnZfqlJzNnZ2d@giganews.com>
Lines: 33
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-rYcurBTi5jOs9yxuy61GisIQuP/Ep0hbpGnj7uH0C61XSom/mrVOod61u81Ipxct3+8r7myMQplw89k!ysy9I2MUAVox4I1UEszwFjZ9biJvDUcOmKsNXpRI6feXq5NpWyciiUcYjjg6uNxlQ/mg1RJ51IM=
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
 by: olcott - Wed, 17 Aug 2022 14:08 UTC

On 8/17/2022 4:15 AM, Mikko wrote:
> On 2022-08-17 01:23:59 +0000, olcott said:
>
>> *Not at all. No one has disproved this statement*
>> H(P,P) does correctly predict that its correct and complete x86
>> emulation of its input would never stop running, thus does correctly
>> reject this input as non-halting.
>
> This is not really a prediction >

Yes it is really a prediction, otherwise H(P,P) would be required to
simulate its input forever.

> as it is about a sitation that will
> never happen.

It will never happen with H, because H always aborts the simlation of
every input that would not otherwise stop running.

> A conterfactual statement does not prove or refute
> anything.
>
> Mikko
>

It only seems counter-factual because of your errors.

--
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: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<kyCdnWCxIsAqZGH_nZ2dnZfqlJ_NnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!feeder.usenetexpress.com!tr2.iad1.usenetexpress.com!69.80.99.14.MISMATCH!border-1.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 17 Aug 2022 14:22:47 +0000
Date: Wed, 17 Aug 2022 09:23:09 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Thunderbird/91.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com> <Z7mdndrO-6onPGb_nZ2dnZfqlJxh4p2d@giganews.com> <f64d20e6-86f3-4f50-a643-e4b6d7fe2ca5n@googlegroups.com> <A46dnW7Luri5NGb_nZ2dnZfqlJ_NnZ2d@giganews.com> <eeXKK.159378$%i2.92635@fx48.iad> <s0-dnfITQe3_32H_nZ2dnZfqlJ_NnZ2d@giganews.com> <rUXKK.733786$5fVf.382893@fx09.iad> <tdhir4$astl$1@dont-email.me> <e669a38a-d240-4a92-aa36-07d3ef57b171n@googlegroups.com> <2uqdnYI1ZK9Zy2H_nZ2dnZfqlJzNnZ2d@giganews.com> <827c17dc-b5c5-4023-b73c-f77925c56c1an@googlegroups.com> <u8udnaC_csJhwGH_nZ2dnZfqlJxh4p2d@giganews.com> <cf36a0c8-68d3-4eae-bcc2-39e36c5b1403n@googlegroups.com> <sySdnc8OUfRL_2H_nZ2dnZfqlJ9g4p2d@giganews.com> <afafbc24-9373-4686-ac19-909a06ffaf79n@googlegroups.com> <c3Sdnf2c2IG_-mH_nZ2dnZfqlJ_NnZ2d@giganews.com> <2b06c9cb-4cb3-4866-a4ad-a5e9f10a6270n@googlegroups.com> <h_qdnUg9Jqn282H_nZ2dnZfqlJzNnZ2d@giganews.com> <92857281-cb53-4ddc-908a-50d2937c403en@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <92857281-cb53-4ddc-908a-50d2937c403en@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <kyCdnWCxIsAqZGH_nZ2dnZfqlJ_NnZ2d@giganews.com>
Lines: 121
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-x9Oh1MnBXHObm1a6NrX76LqTNuHoZUNOucHXOQ+qahZUoJ+DV1pjRO0xHWO0yp/69hTd5R/Iy0x519h!BUkIwm9oxRf2EuTNuoDADGKuTbJt9fVKFryqZVIM8xs5J/wKk8KqYG7lhheIPBFG9Hr6WF5fxss=
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-Received-Bytes: 8640
 by: olcott - Wed, 17 Aug 2022 14:23 UTC

On 8/17/2022 6:40 AM, Dennis Bush wrote:
> On Wednesday, August 17, 2022 at 12:28:52 AM UTC-4, olcott wrote:
>> On 8/16/2022 11:02 PM, Dennis Bush wrote:
>>> On Tuesday, August 16, 2022 at 11:57:51 PM UTC-4, olcott wrote:
>>>> On 8/16/2022 10:53 PM, Dennis Bush wrote:
>>>>> On Tuesday, August 16, 2022 at 11:39:32 PM UTC-4, olcott wrote:
>>>>>> On 8/16/2022 10:23 PM, Dennis Bush wrote:
>>>>>>> On Tuesday, August 16, 2022 at 11:18:46 PM UTC-4, olcott wrote:
>>>>>>>> On 8/16/2022 9:52 PM, Dennis Bush wrote:
>>>>>>>>> On Tuesday, August 16, 2022 at 10:47:57 PM UTC-4, olcott wrote:
>>>>>>>>>> On 8/16/2022 9:34 PM, Dennis Bush wrote:
>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:12:55 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 8/16/2022 8:55 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 8/16/22 9:20 PM, olcott wrote:
>>>>>>>>>>>>>> On 8/16/2022 8:10 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 8/16/22 10:27 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 8/16/2022 9:07 AM, Skep Dick wrote:
>>>>>>>>>>>>>>>>> On Tuesday, 16 August 2022 at 15:55:30 UTC+2, olcott wrote:
>>>>>>>>>>>>>>>>>> The correct and complete x86 emulation of the input to H(P,P) by H
>>>>>>>>>>>>>>>>>> WOULD
>>>>>>>>>>>>>>>>>> never stop running.
>>>>>>>>>>>>>>>>> Sounds like you are stuck in a loop.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Maybe your Decider/Maker should terminate you.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I have been trying to get an honest person to acknowledge the
>>>>>>>>>>>>>>>> correct software engineering of my system so that we can move on to
>>>>>>>>>>>>>>>> the next point for a year now. (bot many honest people here, mostly
>>>>>>>>>>>>>>>> trolls).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The problem is that what you say ISN'T CORRECT software engineering.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You use the wrong definition of things and incorrect assumptions
>>>>>>>>>>>>>>> about thing, so it just isn't true.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H(P,P) does correctly predict that its correct and complete x86
>>>>>>>>>>>>>>>> emulation of its input would never stop running, thus does correctly
>>>>>>>>>>>>>>>> reject this input as non-halting.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Nope. And in fact, you even acknoldge it doesn't but just don't see it.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So you are saying that the correct and complete x86 emulation by
>>>>>>>>>>>>>> H(P,P) of its input WOULD STOP RUNNING?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, I am saying that you H doesn't do a correct and complete emulation
>>>>>>>>>>>>> of its input, and thus to say it did is just a LIE.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> I said that H correctly predicts what the behavior of its correct and
>>>>>>>>>>>> complete x86 emulation of H(P,P) would be
>>>>>>>>>>>
>>>>>>>>>>> The fixed source code of H (and everything it calls) that aborts is Ha. Ha *always* aborts Pa, so "the correct and complete simulation of Ha(Pa,Pa)" does not exist, just like the shoes that Napoleon wore on Mars do not exist.
>>>>>>>>>> So you are another brain dead moron the believes it is utterly
>>>>>>>>>> impossible for H to correctly predict that its correct and complete x86
>>>>>>>>>> emulation of its input would never stop running unless H actually
>>>>>>>>>> performed a correct and complete emulation of its input.
>>>>>>>>>
>>>>>>>>> The correct and complete emulation of Ha(Pa,Pa) doesn't exist,
>>>>>>>> Neither does the correct and complete emulation of Infinite_Loop()
>>>>>>>
>>>>>>> Yes it does. If you simulate Infinite_Loop(), it won't halt. But if you run Ha(Pa,Pa), it won't do a correct and complete simulation because it aborts.
>>>>>> When you run H0((u32)Infinite_Loop)
>>>>>> "it won't do a correct and complete simulation because it aborts"
>>>>>> How long are you going to keep the head game up?
>>>>>
>>>>> That you don't understand what I'm saying doesn't make it a head game.
>>>>>
>>>> You reject Ha(Pa,Pa) on this basis
>>>> run Ha(Pa,Pa), it won't do a correct and complete simulation because it
>>>> aborts.
>>>> Yet accept P0(Infinite_Loop), on the same basis
>>>> it won't do a correct and complete simulation because it aborts.
>>>> ∴ You are playing head games.
>>>
>>> What does P0 do? Does it abort? If so, then yes P0(Infinite_Loop) doesn't do a correct and complete simulation because it aborts, so it's invalid to predict what the correct and complete simulation of P0(Infinite_Loop) would do.
>>>
>>> On the other hand, UTM(Infinite_Loop) does do a correct and complete simulation, so it *is* valid to predict what it will do.
>>>
>> In other words you are not bright enough to see that it is very easy for
>> H0 to recognize an infinite loop would never halt in a finite number of
>> steps of simulation?
>
> I'm saying that H0 can see that the correct and complete simulation performed by UTM(Infinite_Loop) does not halt. It does not and cannot see that the correct and complete simulation performed by H0(Infinite_Loop) (i.e. your basis for correctness) does not halt because H0 does not perform a correct and complete simulation.
>

This is what I mean by H evaluating what its correct and complete
simulation of its input would be:

void P(ptr x)
{ int Halt_Status = Simulate(x, x);
if (Halt_Status)
HERE: goto HERE;
return;
}

Although H itself does not perform a correct and complete simulation of
non-halting inputs H does correctly predict that such a simulation would
never halt.

The fact that H aborts its simulation non-halting inputs does not
contradict the fact that they do not halt.

It is an axiom that whenever H must abort the simulation of any input to
prevent infinite simulation, that H is correct to reject this input as
non-halting.

> In the same way, Ha does not and cannot see that the correct and complete simulation performed by Ha(Pa,Pa) does not halt because Ha does not perform a correct and complete simulation. As above, what does perform a correct and complete simulation is UTM(Pa,Pa) which does halt, therefore Ha(Pa,Pa)==0 is wrong.

--
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: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<21aaa5c2-cb81-43a6-84e4-7a35640a39fdn@googlegroups.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
X-Received: by 2002:a05:620a:1537:b0:6ba:be3d:d70f with SMTP id n23-20020a05620a153700b006babe3dd70fmr18814864qkk.578.1660746951017;
Wed, 17 Aug 2022 07:35:51 -0700 (PDT)
X-Received: by 2002:a25:add1:0:b0:691:3523:13c8 with SMTP id
d17-20020a25add1000000b00691352313c8mr1777411ybe.52.1660746950798; Wed, 17
Aug 2022 07:35:50 -0700 (PDT)
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border-2.nntp.ord.giganews.com!nntp.giganews.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Wed, 17 Aug 2022 07:35:50 -0700 (PDT)
In-Reply-To: <87wnb73wrl.fsf@bsb.me.uk>
Injection-Info: google-groups.googlegroups.com; posting-host=2a00:23a8:400a:5601:2977:fdf7:138:4c44;
posting-account=Dz2zqgkAAADlK5MFu78bw3ab-BRFV4Qn
NNTP-Posting-Host: 2a00:23a8:400a:5601:2977:fdf7:138:4c44
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<3BBKK.730686$5fVf.367715@fx09.iad> <Vp6dnZdlCtCndWf_nZ2dnZfqlJzNnZ2d@giganews.com>
<82CKK.917261$JVi.344055@fx17.iad> <V86dnTZgD6Bacmf_nZ2dnZfqlJzNnZ2d@giganews.com>
<IGCKK.131460$dh2.119930@fx46.iad> <rf6dne7Bna80ZGf_nZ2dnZfqlJzNnZ2d@giganews.com>
<r9DKK.750232$ntj.655539@fx15.iad> <LX-dnT2cwJELnmb_nZ2dnZfqlJ9g4p2d@giganews.com>
<JCDKK.772034$ssF.405468@fx14.iad> <19WdnXfCmdUglWb_nZ2dnZfqlJxh4p2d@giganews.com>
<tZKKK.773109$ssF.431398@fx14.iad> <3e1e8c27-ec66-4eae-89b0-bd144bb1cd1bn@googlegroups.com>
<Z7mdndrO-6onPGb_nZ2dnZfqlJxh4p2d@giganews.com> <f64d20e6-86f3-4f50-a643-e4b6d7fe2ca5n@googlegroups.com>
<A46dnW7Luri5NGb_nZ2dnZfqlJ_NnZ2d@giganews.com> <eeXKK.159378$%i2.92635@fx48.iad>
<s0-dnfITQe3_32H_nZ2dnZfqlJ_NnZ2d@giganews.com> <6b3ad507-9de4-4a18-b63d-ad8c0e163ed9n@googlegroups.com>
<b_Kcnf8WbMNH6WH_nZ2dnZfqlJ_NnZ2d@giganews.com> <fcd6e828-f966-4731-8061-5665a22f970fn@googlegroups.com>
<87wnb73wrl.fsf@bsb.me.uk>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <21aaa5c2-cb81-43a6-84e4-7a35640a39fdn@googlegroups.com>
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
From: malcolm....@gmail.com (Malcolm McLean)
Injection-Date: Wed, 17 Aug 2022 14:35:51 +0000
Content-Type: text/plain; charset="UTF-8"
Lines: 21
 by: Malcolm McLean - Wed, 17 Aug 2022 14:35 UTC

On Wednesday, 17 August 2022 at 13:00:34 UTC+1, Ben Bacarisse wrote:
> "dklei...@gmail.com" <dklei...@gmail.com> writes:
>
> > On Tuesday, August 16, 2022 at 9:56:23 PM UTC-7, olcott wrote:
> >> On 8/16/2022 11:52 PM, dklei...@gmail.com wrote:
> >> > On Tuesday, August 16, 2022 at 6:21:04 PM UTC-7, olcott wrote:
> >> >>
> >> >> So you are saying that the correct and complete x86 emulation by H(P,P)
> >> >> of its input WOULD STOP RUNNING?
> >> >>
> >> > H is , by definition, a Turing Machine and therefore halts.
> Did you mean to say that? Perhaps you meant to say that H is, by
> definition, a decider and a decider halts regardless of the initial
> tape?
>
> (Also, some authors define "a computation" as a finite sequence of TM
> configurations so, in that view, all TM computations are, by definition,
> halting.)
>
Say we use decimal notation. It's possible to create a machine which maintains
the digits of PI in a growing list at the left of the tape. It will never halt. But it's
not a normal use of language to say it is not performing a "computation".

Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<772d0a3b-f170-40c0-8abb-6569ae6cc5d5n@googlegroups.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
X-Received: by 2002:a05:620a:128a:b0:6bb:5a52:6dd8 with SMTP id w10-20020a05620a128a00b006bb5a526dd8mr7318452qki.350.1660747861896;
Wed, 17 Aug 2022 07:51:01 -0700 (PDT)
X-Received: by 2002:a5b:289:0:b0:68b:73d6:79f4 with SMTP id
x9-20020a5b0289000000b0068b73d679f4mr9413391ybl.99.1660747861691; Wed, 17 Aug
2022 07:51:01 -0700 (PDT)
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Wed, 17 Aug 2022 07:51:01 -0700 (PDT)
In-Reply-To: <kyCdnWCxIsAqZGH_nZ2dnZfqlJ_NnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=98.110.86.97; posting-account=ejFcQgoAAACAt5i0VbkATkR2ACWdgADD
NNTP-Posting-Host: 98.110.86.97
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<Z7mdndrO-6onPGb_nZ2dnZfqlJxh4p2d@giganews.com> <f64d20e6-86f3-4f50-a643-e4b6d7fe2ca5n@googlegroups.com>
<A46dnW7Luri5NGb_nZ2dnZfqlJ_NnZ2d@giganews.com> <eeXKK.159378$%i2.92635@fx48.iad>
<s0-dnfITQe3_32H_nZ2dnZfqlJ_NnZ2d@giganews.com> <rUXKK.733786$5fVf.382893@fx09.iad>
<tdhir4$astl$1@dont-email.me> <e669a38a-d240-4a92-aa36-07d3ef57b171n@googlegroups.com>
<2uqdnYI1ZK9Zy2H_nZ2dnZfqlJzNnZ2d@giganews.com> <827c17dc-b5c5-4023-b73c-f77925c56c1an@googlegroups.com>
<u8udnaC_csJhwGH_nZ2dnZfqlJxh4p2d@giganews.com> <cf36a0c8-68d3-4eae-bcc2-39e36c5b1403n@googlegroups.com>
<sySdnc8OUfRL_2H_nZ2dnZfqlJ9g4p2d@giganews.com> <afafbc24-9373-4686-ac19-909a06ffaf79n@googlegroups.com>
<c3Sdnf2c2IG_-mH_nZ2dnZfqlJ_NnZ2d@giganews.com> <2b06c9cb-4cb3-4866-a4ad-a5e9f10a6270n@googlegroups.com>
<h_qdnUg9Jqn282H_nZ2dnZfqlJzNnZ2d@giganews.com> <92857281-cb53-4ddc-908a-50d2937c403en@googlegroups.com>
<kyCdnWCxIsAqZGH_nZ2dnZfqlJ_NnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <772d0a3b-f170-40c0-8abb-6569ae6cc5d5n@googlegroups.com>
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
From: dbush.mo...@gmail.com (Dennis Bush)
Injection-Date: Wed, 17 Aug 2022 14:51:01 +0000
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
X-Received-Bytes: 8745
 by: Dennis Bush - Wed, 17 Aug 2022 14:51 UTC

On Wednesday, August 17, 2022 at 10:23:17 AM UTC-4, olcott wrote:
> On 8/17/2022 6:40 AM, Dennis Bush wrote:
> > On Wednesday, August 17, 2022 at 12:28:52 AM UTC-4, olcott wrote:
> >> On 8/16/2022 11:02 PM, Dennis Bush wrote:
> >>> On Tuesday, August 16, 2022 at 11:57:51 PM UTC-4, olcott wrote:
> >>>> On 8/16/2022 10:53 PM, Dennis Bush wrote:
> >>>>> On Tuesday, August 16, 2022 at 11:39:32 PM UTC-4, olcott wrote:
> >>>>>> On 8/16/2022 10:23 PM, Dennis Bush wrote:
> >>>>>>> On Tuesday, August 16, 2022 at 11:18:46 PM UTC-4, olcott wrote:
> >>>>>>>> On 8/16/2022 9:52 PM, Dennis Bush wrote:
> >>>>>>>>> On Tuesday, August 16, 2022 at 10:47:57 PM UTC-4, olcott wrote:
> >>>>>>>>>> On 8/16/2022 9:34 PM, Dennis Bush wrote:
> >>>>>>>>>>> On Tuesday, August 16, 2022 at 10:12:55 PM UTC-4, olcott wrote:
> >>>>>>>>>>>> On 8/16/2022 8:55 PM, Richard Damon wrote:
> >>>>>>>>>>>>> On 8/16/22 9:20 PM, olcott wrote:
> >>>>>>>>>>>>>> On 8/16/2022 8:10 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>> On 8/16/22 10:27 AM, olcott wrote:
> >>>>>>>>>>>>>>>> On 8/16/2022 9:07 AM, Skep Dick wrote:
> >>>>>>>>>>>>>>>>> On Tuesday, 16 August 2022 at 15:55:30 UTC+2, olcott wrote:
> >>>>>>>>>>>>>>>>>> The correct and complete x86 emulation of the input to H(P,P) by H
> >>>>>>>>>>>>>>>>>> WOULD
> >>>>>>>>>>>>>>>>>> never stop running.
> >>>>>>>>>>>>>>>>> Sounds like you are stuck in a loop.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Maybe your Decider/Maker should terminate you.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> I have been trying to get an honest person to acknowledge the
> >>>>>>>>>>>>>>>> correct software engineering of my system so that we can move on to
> >>>>>>>>>>>>>>>> the next point for a year now. (bot many honest people here, mostly
> >>>>>>>>>>>>>>>> trolls).
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> The problem is that what you say ISN'T CORRECT software engineering.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> You use the wrong definition of things and incorrect assumptions
> >>>>>>>>>>>>>>> about thing, so it just isn't true.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> H(P,P) does correctly predict that its correct and complete x86
> >>>>>>>>>>>>>>>> emulation of its input would never stop running, thus does correctly
> >>>>>>>>>>>>>>>> reject this input as non-halting.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Nope. And in fact, you even acknoldge it doesn't but just don't see it.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> So you are saying that the correct and complete x86 emulation by
> >>>>>>>>>>>>>> H(P,P) of its input WOULD STOP RUNNING?
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> No, I am saying that you H doesn't do a correct and complete emulation
> >>>>>>>>>>>>> of its input, and thus to say it did is just a LIE.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> I said that H correctly predicts what the behavior of its correct and
> >>>>>>>>>>>> complete x86 emulation of H(P,P) would be
> >>>>>>>>>>>
> >>>>>>>>>>> The fixed source code of H (and everything it calls) that aborts is Ha. Ha *always* aborts Pa, so "the correct and complete simulation of Ha(Pa,Pa)" does not exist, just like the shoes that Napoleon wore on Mars do not exist.
> >>>>>>>>>> So you are another brain dead moron the believes it is utterly
> >>>>>>>>>> impossible for H to correctly predict that its correct and complete x86
> >>>>>>>>>> emulation of its input would never stop running unless H actually
> >>>>>>>>>> performed a correct and complete emulation of its input.
> >>>>>>>>>
> >>>>>>>>> The correct and complete emulation of Ha(Pa,Pa) doesn't exist,
> >>>>>>>> Neither does the correct and complete emulation of Infinite_Loop()
> >>>>>>>
> >>>>>>> Yes it does. If you simulate Infinite_Loop(), it won't halt. But if you run Ha(Pa,Pa), it won't do a correct and complete simulation because it aborts.
> >>>>>> When you run H0((u32)Infinite_Loop)
> >>>>>> "it won't do a correct and complete simulation because it aborts"
> >>>>>> How long are you going to keep the head game up?
> >>>>>
> >>>>> That you don't understand what I'm saying doesn't make it a head game.
> >>>>>
> >>>> You reject Ha(Pa,Pa) on this basis
> >>>> run Ha(Pa,Pa), it won't do a correct and complete simulation because it
> >>>> aborts.
> >>>> Yet accept P0(Infinite_Loop), on the same basis
> >>>> it won't do a correct and complete simulation because it aborts.
> >>>> ∴ You are playing head games.
> >>>
> >>> What does P0 do? Does it abort? If so, then yes P0(Infinite_Loop) doesn't do a correct and complete simulation because it aborts, so it's invalid to predict what the correct and complete simulation of P0(Infinite_Loop) would do.
> >>>
> >>> On the other hand, UTM(Infinite_Loop) does do a correct and complete simulation, so it *is* valid to predict what it will do.
> >>>
> >> In other words you are not bright enough to see that it is very easy for
> >> H0 to recognize an infinite loop would never halt in a finite number of
> >> steps of simulation?
> >
> > I'm saying that H0 can see that the correct and complete simulation performed by UTM(Infinite_Loop) does not halt. It does not and cannot see that the correct and complete simulation performed by H0(Infinite_Loop) (i.e. your basis for correctness) does not halt because H0 does not perform a correct and complete simulation.
> >
> This is what I mean by H evaluating what its correct and complete
> simulation of its input would be:
>
> void P(ptr x)
> {
> int Halt_Status = Simulate(x, x);
> if (Halt_Status)
> HERE: goto HERE;
> return;
> }
>
> Although H itself does not perform a correct and complete simulation of
> non-halting inputs H does correctly predict that such a simulation would
> never halt.

You changed the input from Pa to Pn.

So you're again saying that Ha(Pa,Pa) reports the halt status of the non-input Pn(Pn) instead of Pa(Pa) as it is required to:

For *any* algorithm X and input Y:
H(X,Y)==1 if and only if X(Y) halts, and
H(X,Y)==0 if and only if X(Y) does not halt

Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<ENOdndtEMevGmWD_nZ2dnZfqlJzNnZ2d@giganews.com>

  copy mid

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

  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!border-1.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 17 Aug 2022 15:08:11 +0000
Date: Wed, 17 Aug 2022 10:08:27 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<82CKK.917261$JVi.344055@fx17.iad>
<V86dnTZgD6Bacmf_nZ2dnZfqlJzNnZ2d@giganews.com>
<IGCKK.131460$dh2.119930@fx46.iad>
<rf6dne7Bna80ZGf_nZ2dnZfqlJzNnZ2d@giganews.com>
<r9DKK.750232$ntj.655539@fx15.iad>
<LX-dnT2cwJELnmb_nZ2dnZfqlJ9g4p2d@giganews.com>
<JCDKK.772034$ssF.405468@fx14.iad>
<19WdnXfCmdUglWb_nZ2dnZfqlJxh4p2d@giganews.com>
<tZKKK.773109$ssF.431398@fx14.iad>
<3e1e8c27-ec66-4eae-89b0-bd144bb1cd1bn@googlegroups.com>
<Z7mdndrO-6onPGb_nZ2dnZfqlJxh4p2d@giganews.com>
<f64d20e6-86f3-4f50-a643-e4b6d7fe2ca5n@googlegroups.com>
<A46dnW7Luri5NGb_nZ2dnZfqlJ_NnZ2d@giganews.com>
<eeXKK.159378$%i2.92635@fx48.iad>
<s0-dnfITQe3_32H_nZ2dnZfqlJ_NnZ2d@giganews.com>
<6b3ad507-9de4-4a18-b63d-ad8c0e163ed9n@googlegroups.com>
<b_Kcnf8WbMNH6WH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<fcd6e828-f966-4731-8061-5665a22f970fn@googlegroups.com>
<nLOdnZYR-unTHmH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<TC4LK.734216$5fVf.250358@fx09.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <TC4LK.734216$5fVf.250358@fx09.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <ENOdndtEMevGmWD_nZ2dnZfqlJzNnZ2d@giganews.com>
Lines: 178
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-7fDxGenX3oYpNo8Q8EfQp0heApuL+Nx9ngoQAMZvwyUbyBfbcovji5Z+JsweXLYrasYRtQZucrTaztT!JRJaz35d+0tGj+MkMxxvMUmrbAGA1V1Aj9bTZJWYhY2pqvsHmNcNA+x8cwm0Dp3it2oP8q3F+MY=
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-Received-Bytes: 9344
 by: olcott - Wed, 17 Aug 2022 15:08 UTC

On 8/17/2022 6:51 AM, Richard Damon wrote:
> On 8/17/22 1:57 AM, olcott wrote:
>> On 8/17/2022 12:02 AM, dklei...@gmail.com wrote:
>>> On Tuesday, August 16, 2022 at 9:56:23 PM UTC-7, olcott wrote:
>>>> On 8/16/2022 11:52 PM, dklei...@gmail.com wrote:
>>>>> On Tuesday, August 16, 2022 at 6:21:04 PM UTC-7, olcott wrote:
>>>>>>
>>>>>> So you are saying that the correct and complete x86 emulation by
>>>>>> H(P,P)
>>>>>> of its input WOULD STOP RUNNING?
>>>>>>
>>>>> H is , by definition, a Turing Machine and therefore halts.
>>>> H is a C function that I hope to show is a valid proxy for TM at some
>>>> future date, after it is accepted that H(P,P)==0 is correct software
>>>> engineering.
>>>>
>>>> I am biding my time here while I am preparing the code for a much wider
>>>> audience.
>>>>
>>> H the C program is assumed equivalent to H the Turing Machine.
>>
>> H is a C function, not a program and I made it as Turing equivalent as
>> I could. H always returns the same value for the same arguments every
>> time that it is invoked.
>
> And this is a key part of your error.

H(P,P) does correctly determine that its input never halts there is no
error in this.

> Computations are much more like
> "Programs" then "Functions" in a programming language, as they include
> ALL the behavor from invocation to return, not just the behavior inside
> the lexical scope of the source code of that particular function.
>

The program-under-test: P does not halt.
H(P,P) correctly predicts that its correct and complete simulation of
its input would never reach the final state "return instruction" of P.
Within these definitions H(P,P)==0 is correct.

> Thus, the P in P(P) fully includes ALL of H and everything it calls as
> part of it. Including its SPECIFIC implementation of any algorithms.
>

If you define things this way that a student that gets an F on a test
did not flunk this test because the teacher did not flunk any test.

The fact that H aborts its simulation non-halting inputs does not
contradict the fact that they do not halt.

It is an axiom that whenever H must abort the simulation of any input to
prevent infinite simulation, that H is correct to reject this input as
non-halting.

This is not "Pete's other halting problem" because it uses the same
criteria as the halting problem. H(P,P) correctly predicts that its
correct and complete simulation of its input would never reach the final
state "return instruction" of this simulated input.

> Turing Macnines are ALWAYS the equivalent of a "Program", not an
> embedded function.
>

You did not say that precisely enough:

Turing Machines are ALWAYS the equivalent of a "Program", not [ALWAYS
equivalent to] an embedded function.

> When you make the Turing Machine Equivalent of P, then that machine, to
> be built, includes in it its own copy of the code of H to implment the
> call to H.
>

That only makes the proof more difficult to understand it does not
change the result.

Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy
If the correctly simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ to H would reach its own final
state of ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩.

Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
If the correctly simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ to H would never reach its own
final state of ⟨Ĥ.qy⟩ or ⟨Ĥ.qn⟩.

When Ĥ is applied to ⟨Ĥ⟩ // subscripts indicate unique finite strings
Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩

Then these steps would keep repeating: (unless their simulation is aborted)
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...

It is still the case that the simulated input never reaches a final
state of this simulated input.

Linz did not bother to pay attention to the distinction between the
program-under-test and the test program.

When the embedded copy of H is applied to ⟨Ĥ0⟩ ⟨Ĥ1⟩ this embedded copy
of H is not determining whether or not itself halts, itself and its
program-under-test are ion two different process contexts.

When a UTM simulates a TM description this simulated TM gets a portion
of the UTM tape to use as its own tape. The UTM does not use this
reserved portion. The UTM and its simulated input are in the TM
equivalent of different process contexts.

> H, on the other hand, is given the representation of P(P) which it needs
> to decide on, in your case starting by simulating it. Note, that since
> this input has its own copy of H, your "Address Comparison" trick just
> fails to handle this model.

Linz asks the question: (Linz:1990:320)
We can therefore legitimately ask:
What would happen if Ĥ is applied to ⟨Ĥ⟩?

When Ĥ is applied to ⟨Ĥ⟩ // subscripts indicate unique finite strings
Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩

> Your problem is that Computationally, your H
> isn't a complete program by itself, that has an input, but you build a
> different program for each input which bundles H and the input together.
>

This has no effect on the results, it is merely more difficult to
understand. The more complex case can be understood on the basis of
fully understanding the simpler case.

H(P,P) does correctly predict that its correct and complete x86
emulation of its input would never stop running, (or reach the final
state "return" instruction of this simulated input) thus does correctly
reject this input as non-halting.

> You can't create as two totally distinct pieces, an H that matches your
> requirements, and a P that can run as a totally seperate program and
> also be made the input to H.
>

This is moot.
Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy
Ĥ.q0 ⟨Ĥ⟩ ⊢* H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

Ĥ ⟨Ĥ⟩ ⊢* H ⟨Ĥ0⟩ ⟨Ĥ1⟩ ⊢* Ĥ.qn
on the basis that the simulated input ⟨Ĥ0⟩ ⟨Ĥ1⟩ would never reach the
final state OF THIS SIMULATED INPUT: ⟨Ĥ0.qy⟩ or ⟨Ĥ0.qn⟩.

>>
>> The computer scientist seemed to think (this may be a bad paraphrase)
>> that H must return the same value for the same arguments EVEN IF H IS
>> NOT INVOKED.
>>
>
> No, only if it is invoked,

Then the fact that the simulated H(P,P) is never invoked does not
prevent H from being a pure function.

> but the call H in P, when emulated,

it is never emulated, the simulation of P is aborted before the
simulated H is ever emulated.

> needs to
> fully behave like all other invocations of that H, as H HAS ben invoked,
> even if your simulator hasn't gone into it.
>

--
Copyright 2022 Pete Olcott

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

Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<xvydnfdGtIaElWD_nZ2dnZfqlJzNnZ2d@giganews.com>

  copy mid

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

  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!feeder.usenetexpress.com!tr2.iad1.usenetexpress.com!69.80.99.14.MISMATCH!border-1.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 17 Aug 2022 15:24:09 +0000
Date: Wed, 17 Aug 2022 10:24:26 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Thunderbird/91.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com> <A46dnW7Luri5NGb_nZ2dnZfqlJ_NnZ2d@giganews.com> <eeXKK.159378$%i2.92635@fx48.iad> <s0-dnfITQe3_32H_nZ2dnZfqlJ_NnZ2d@giganews.com> <rUXKK.733786$5fVf.382893@fx09.iad> <tdhir4$astl$1@dont-email.me> <e669a38a-d240-4a92-aa36-07d3ef57b171n@googlegroups.com> <2uqdnYI1ZK9Zy2H_nZ2dnZfqlJzNnZ2d@giganews.com> <827c17dc-b5c5-4023-b73c-f77925c56c1an@googlegroups.com> <u8udnaC_csJhwGH_nZ2dnZfqlJxh4p2d@giganews.com> <cf36a0c8-68d3-4eae-bcc2-39e36c5b1403n@googlegroups.com> <sySdnc8OUfRL_2H_nZ2dnZfqlJ9g4p2d@giganews.com> <afafbc24-9373-4686-ac19-909a06ffaf79n@googlegroups.com> <c3Sdnf2c2IG_-mH_nZ2dnZfqlJ_NnZ2d@giganews.com> <2b06c9cb-4cb3-4866-a4ad-a5e9f10a6270n@googlegroups.com> <h_qdnUg9Jqn282H_nZ2dnZfqlJzNnZ2d@giganews.com> <92857281-cb53-4ddc-908a-50d2937c403en@googlegroups.com> <kyCdnWCxIsAqZGH_nZ2dnZfqlJ_NnZ2d@giganews.com> <772d0a3b-f170-40c0-8abb-6569ae6cc5d5n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <772d0a3b-f170-40c0-8abb-6569ae6cc5d5n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <xvydnfdGtIaElWD_nZ2dnZfqlJzNnZ2d@giganews.com>
Lines: 156
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-hEETLgybJ0RGhUeYErJcvL+RVGzSEHhGSTO1lNX1S5Hdx8zpn6Z8y3z2aBdro4LGlf2Q4ZuKuCCBr4H!mqqF/K32nnkOd8NLt0HGydhQTsHmJc66qytVCED2TD53HFfgODDggzTKlxo/YunctanXMAVTpww=
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-Received-Bytes: 9877
 by: olcott - Wed, 17 Aug 2022 15:24 UTC

On 8/17/2022 9:51 AM, Dennis Bush wrote:
> On Wednesday, August 17, 2022 at 10:23:17 AM UTC-4, olcott wrote:
>> On 8/17/2022 6:40 AM, Dennis Bush wrote:
>>> On Wednesday, August 17, 2022 at 12:28:52 AM UTC-4, olcott wrote:
>>>> On 8/16/2022 11:02 PM, Dennis Bush wrote:
>>>>> On Tuesday, August 16, 2022 at 11:57:51 PM UTC-4, olcott wrote:
>>>>>> On 8/16/2022 10:53 PM, Dennis Bush wrote:
>>>>>>> On Tuesday, August 16, 2022 at 11:39:32 PM UTC-4, olcott wrote:
>>>>>>>> On 8/16/2022 10:23 PM, Dennis Bush wrote:
>>>>>>>>> On Tuesday, August 16, 2022 at 11:18:46 PM UTC-4, olcott wrote:
>>>>>>>>>> On 8/16/2022 9:52 PM, Dennis Bush wrote:
>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:47:57 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 8/16/2022 9:34 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:12:55 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 8/16/2022 8:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 8/16/22 9:20 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 8/16/2022 8:10 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 8/16/22 10:27 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 8/16/2022 9:07 AM, Skep Dick wrote:
>>>>>>>>>>>>>>>>>>> On Tuesday, 16 August 2022 at 15:55:30 UTC+2, olcott wrote:
>>>>>>>>>>>>>>>>>>>> The correct and complete x86 emulation of the input to H(P,P) by H
>>>>>>>>>>>>>>>>>>>> WOULD
>>>>>>>>>>>>>>>>>>>> never stop running.
>>>>>>>>>>>>>>>>>>> Sounds like you are stuck in a loop.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Maybe your Decider/Maker should terminate you.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I have been trying to get an honest person to acknowledge the
>>>>>>>>>>>>>>>>>> correct software engineering of my system so that we can move on to
>>>>>>>>>>>>>>>>>> the next point for a year now. (bot many honest people here, mostly
>>>>>>>>>>>>>>>>>> trolls).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The problem is that what you say ISN'T CORRECT software engineering.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You use the wrong definition of things and incorrect assumptions
>>>>>>>>>>>>>>>>> about thing, so it just isn't true.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> H(P,P) does correctly predict that its correct and complete x86
>>>>>>>>>>>>>>>>>> emulation of its input would never stop running, thus does correctly
>>>>>>>>>>>>>>>>>> reject this input as non-halting.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Nope. And in fact, you even acknoldge it doesn't but just don't see it.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So you are saying that the correct and complete x86 emulation by
>>>>>>>>>>>>>>>> H(P,P) of its input WOULD STOP RUNNING?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, I am saying that you H doesn't do a correct and complete emulation
>>>>>>>>>>>>>>> of its input, and thus to say it did is just a LIE.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I said that H correctly predicts what the behavior of its correct and
>>>>>>>>>>>>>> complete x86 emulation of H(P,P) would be
>>>>>>>>>>>>>
>>>>>>>>>>>>> The fixed source code of H (and everything it calls) that aborts is Ha. Ha *always* aborts Pa, so "the correct and complete simulation of Ha(Pa,Pa)" does not exist, just like the shoes that Napoleon wore on Mars do not exist.
>>>>>>>>>>>> So you are another brain dead moron the believes it is utterly
>>>>>>>>>>>> impossible for H to correctly predict that its correct and complete x86
>>>>>>>>>>>> emulation of its input would never stop running unless H actually
>>>>>>>>>>>> performed a correct and complete emulation of its input.
>>>>>>>>>>>
>>>>>>>>>>> The correct and complete emulation of Ha(Pa,Pa) doesn't exist,
>>>>>>>>>> Neither does the correct and complete emulation of Infinite_Loop()
>>>>>>>>>
>>>>>>>>> Yes it does. If you simulate Infinite_Loop(), it won't halt. But if you run Ha(Pa,Pa), it won't do a correct and complete simulation because it aborts.
>>>>>>>> When you run H0((u32)Infinite_Loop)
>>>>>>>> "it won't do a correct and complete simulation because it aborts"
>>>>>>>> How long are you going to keep the head game up?
>>>>>>>
>>>>>>> That you don't understand what I'm saying doesn't make it a head game.
>>>>>>>
>>>>>> You reject Ha(Pa,Pa) on this basis
>>>>>> run Ha(Pa,Pa), it won't do a correct and complete simulation because it
>>>>>> aborts.
>>>>>> Yet accept P0(Infinite_Loop), on the same basis
>>>>>> it won't do a correct and complete simulation because it aborts.
>>>>>> ∴ You are playing head games.
>>>>>
>>>>> What does P0 do? Does it abort? If so, then yes P0(Infinite_Loop) doesn't do a correct and complete simulation because it aborts, so it's invalid to predict what the correct and complete simulation of P0(Infinite_Loop) would do.
>>>>>
>>>>> On the other hand, UTM(Infinite_Loop) does do a correct and complete simulation, so it *is* valid to predict what it will do.
>>>>>
>>>> In other words you are not bright enough to see that it is very easy for
>>>> H0 to recognize an infinite loop would never halt in a finite number of
>>>> steps of simulation?
>>>
>>> I'm saying that H0 can see that the correct and complete simulation performed by UTM(Infinite_Loop) does not halt. It does not and cannot see that the correct and complete simulation performed by H0(Infinite_Loop) (i.e. your basis for correctness) does not halt because H0 does not perform a correct and complete simulation.
>>>
>> This is what I mean by H evaluating what its correct and complete
>> simulation of its input would be:
>>
>> void P(ptr x)
>> {
>> int Halt_Status = Simulate(x, x);
>> if (Halt_Status)
>> HERE: goto HERE;
>> return;
>> }
>>
>> Although H itself does not perform a correct and complete simulation of
>> non-halting inputs H does correctly predict that such a simulation would
>> never halt.
>
> You changed the input from Pa to Pn.
>
> So you're again saying that Ha(Pa,Pa) reports the halt status of the non-input Pn(Pn) instead of Pa(Pa) as it is required to:
>

H0(Infinite_Loop)
reports on Simulate(Infinite_Loop)


Click here to read the complete article
Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<0a36df55-771f-4f26-a073-4dc34ac69942n@googlegroups.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
X-Received: by 2002:ac8:5889:0:b0:344:57e5:dc54 with SMTP id t9-20020ac85889000000b0034457e5dc54mr14257914qta.465.1660750550240;
Wed, 17 Aug 2022 08:35:50 -0700 (PDT)
X-Received: by 2002:a25:9f0e:0:b0:691:f74:9ed6 with SMTP id
n14-20020a259f0e000000b006910f749ed6mr2211889ybq.307.1660750549903; Wed, 17
Aug 2022 08:35:49 -0700 (PDT)
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Wed, 17 Aug 2022 08:35:49 -0700 (PDT)
In-Reply-To: <xvydnfdGtIaElWD_nZ2dnZfqlJzNnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=98.110.86.97; posting-account=ejFcQgoAAACAt5i0VbkATkR2ACWdgADD
NNTP-Posting-Host: 98.110.86.97
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<A46dnW7Luri5NGb_nZ2dnZfqlJ_NnZ2d@giganews.com> <eeXKK.159378$%i2.92635@fx48.iad>
<s0-dnfITQe3_32H_nZ2dnZfqlJ_NnZ2d@giganews.com> <rUXKK.733786$5fVf.382893@fx09.iad>
<tdhir4$astl$1@dont-email.me> <e669a38a-d240-4a92-aa36-07d3ef57b171n@googlegroups.com>
<2uqdnYI1ZK9Zy2H_nZ2dnZfqlJzNnZ2d@giganews.com> <827c17dc-b5c5-4023-b73c-f77925c56c1an@googlegroups.com>
<u8udnaC_csJhwGH_nZ2dnZfqlJxh4p2d@giganews.com> <cf36a0c8-68d3-4eae-bcc2-39e36c5b1403n@googlegroups.com>
<sySdnc8OUfRL_2H_nZ2dnZfqlJ9g4p2d@giganews.com> <afafbc24-9373-4686-ac19-909a06ffaf79n@googlegroups.com>
<c3Sdnf2c2IG_-mH_nZ2dnZfqlJ_NnZ2d@giganews.com> <2b06c9cb-4cb3-4866-a4ad-a5e9f10a6270n@googlegroups.com>
<h_qdnUg9Jqn282H_nZ2dnZfqlJzNnZ2d@giganews.com> <92857281-cb53-4ddc-908a-50d2937c403en@googlegroups.com>
<kyCdnWCxIsAqZGH_nZ2dnZfqlJ_NnZ2d@giganews.com> <772d0a3b-f170-40c0-8abb-6569ae6cc5d5n@googlegroups.com>
<xvydnfdGtIaElWD_nZ2dnZfqlJzNnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <0a36df55-771f-4f26-a073-4dc34ac69942n@googlegroups.com>
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
From: dbush.mo...@gmail.com (Dennis Bush)
Injection-Date: Wed, 17 Aug 2022 15:35:50 +0000
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
X-Received-Bytes: 11383
 by: Dennis Bush - Wed, 17 Aug 2022 15:35 UTC

On Wednesday, August 17, 2022 at 11:24:34 AM UTC-4, olcott wrote:
> On 8/17/2022 9:51 AM, Dennis Bush wrote:
> > On Wednesday, August 17, 2022 at 10:23:17 AM UTC-4, olcott wrote:
> >> On 8/17/2022 6:40 AM, Dennis Bush wrote:
> >>> On Wednesday, August 17, 2022 at 12:28:52 AM UTC-4, olcott wrote:
> >>>> On 8/16/2022 11:02 PM, Dennis Bush wrote:
> >>>>> On Tuesday, August 16, 2022 at 11:57:51 PM UTC-4, olcott wrote:
> >>>>>> On 8/16/2022 10:53 PM, Dennis Bush wrote:
> >>>>>>> On Tuesday, August 16, 2022 at 11:39:32 PM UTC-4, olcott wrote:
> >>>>>>>> On 8/16/2022 10:23 PM, Dennis Bush wrote:
> >>>>>>>>> On Tuesday, August 16, 2022 at 11:18:46 PM UTC-4, olcott wrote:
> >>>>>>>>>> On 8/16/2022 9:52 PM, Dennis Bush wrote:
> >>>>>>>>>>> On Tuesday, August 16, 2022 at 10:47:57 PM UTC-4, olcott wrote:
> >>>>>>>>>>>> On 8/16/2022 9:34 PM, Dennis Bush wrote:
> >>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:12:55 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>> On 8/16/2022 8:55 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>> On 8/16/22 9:20 PM, olcott wrote:
> >>>>>>>>>>>>>>>> On 8/16/2022 8:10 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>> On 8/16/22 10:27 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>> On 8/16/2022 9:07 AM, Skep Dick wrote:
> >>>>>>>>>>>>>>>>>>> On Tuesday, 16 August 2022 at 15:55:30 UTC+2, olcott wrote:
> >>>>>>>>>>>>>>>>>>>> The correct and complete x86 emulation of the input to H(P,P) by H
> >>>>>>>>>>>>>>>>>>>> WOULD
> >>>>>>>>>>>>>>>>>>>> never stop running.
> >>>>>>>>>>>>>>>>>>> Sounds like you are stuck in a loop.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> Maybe your Decider/Maker should terminate you.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> I have been trying to get an honest person to acknowledge the
> >>>>>>>>>>>>>>>>>> correct software engineering of my system so that we can move on to
> >>>>>>>>>>>>>>>>>> the next point for a year now. (bot many honest people here, mostly
> >>>>>>>>>>>>>>>>>> trolls).
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> The problem is that what you say ISN'T CORRECT software engineering.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> You use the wrong definition of things and incorrect assumptions
> >>>>>>>>>>>>>>>>> about thing, so it just isn't true.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> H(P,P) does correctly predict that its correct and complete x86
> >>>>>>>>>>>>>>>>>> emulation of its input would never stop running, thus does correctly
> >>>>>>>>>>>>>>>>>> reject this input as non-halting.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Nope. And in fact, you even acknoldge it doesn't but just don't see it.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> So you are saying that the correct and complete x86 emulation by
> >>>>>>>>>>>>>>>> H(P,P) of its input WOULD STOP RUNNING?
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> No, I am saying that you H doesn't do a correct and complete emulation
> >>>>>>>>>>>>>>> of its input, and thus to say it did is just a LIE.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> I said that H correctly predicts what the behavior of its correct and
> >>>>>>>>>>>>>> complete x86 emulation of H(P,P) would be
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> The fixed source code of H (and everything it calls) that aborts is Ha. Ha *always* aborts Pa, so "the correct and complete simulation of Ha(Pa,Pa)" does not exist, just like the shoes that Napoleon wore on Mars do not exist.
> >>>>>>>>>>>> So you are another brain dead moron the believes it is utterly
> >>>>>>>>>>>> impossible for H to correctly predict that its correct and complete x86
> >>>>>>>>>>>> emulation of its input would never stop running unless H actually
> >>>>>>>>>>>> performed a correct and complete emulation of its input.
> >>>>>>>>>>>
> >>>>>>>>>>> The correct and complete emulation of Ha(Pa,Pa) doesn't exist,
> >>>>>>>>>> Neither does the correct and complete emulation of Infinite_Loop()
> >>>>>>>>>
> >>>>>>>>> Yes it does. If you simulate Infinite_Loop(), it won't halt. But if you run Ha(Pa,Pa), it won't do a correct and complete simulation because it aborts.
> >>>>>>>> When you run H0((u32)Infinite_Loop)
> >>>>>>>> "it won't do a correct and complete simulation because it aborts"
> >>>>>>>> How long are you going to keep the head game up?
> >>>>>>>
> >>>>>>> That you don't understand what I'm saying doesn't make it a head game.
> >>>>>>>
> >>>>>> You reject Ha(Pa,Pa) on this basis
> >>>>>> run Ha(Pa,Pa), it won't do a correct and complete simulation because it
> >>>>>> aborts.
> >>>>>> Yet accept P0(Infinite_Loop), on the same basis
> >>>>>> it won't do a correct and complete simulation because it aborts.
> >>>>>> ∴ You are playing head games.
> >>>>>
> >>>>> What does P0 do? Does it abort? If so, then yes P0(Infinite_Loop) doesn't do a correct and complete simulation because it aborts, so it's invalid to predict what the correct and complete simulation of P0(Infinite_Loop) would do.
> >>>>>
> >>>>> On the other hand, UTM(Infinite_Loop) does do a correct and complete simulation, so it *is* valid to predict what it will do.
> >>>>>
> >>>> In other words you are not bright enough to see that it is very easy for
> >>>> H0 to recognize an infinite loop would never halt in a finite number of
> >>>> steps of simulation?
> >>>
> >>> I'm saying that H0 can see that the correct and complete simulation performed by UTM(Infinite_Loop) does not halt. It does not and cannot see that the correct and complete simulation performed by H0(Infinite_Loop) (i.e. your basis for correctness) does not halt because H0 does not perform a correct and complete simulation.
> >>>
> >> This is what I mean by H evaluating what its correct and complete
> >> simulation of its input would be:
> >>
> >> void P(ptr x)
> >> {
> >> int Halt_Status = Simulate(x, x);
> >> if (Halt_Status)
> >> HERE: goto HERE;
> >> return;
> >> }
> >>
> >> Although H itself does not perform a correct and complete simulation of
> >> non-halting inputs H does correctly predict that such a simulation would
> >> never halt.
> >
> > You changed the input from Pa to Pn.
> >
> > So you're again saying that Ha(Pa,Pa) reports the halt status of the non-input Pn(Pn) instead of Pa(Pa) as it is required to:
> >
> H0(Infinite_Loop)
> reports on Simulate(Infinite_Loop)
>
> H(Infinite_Recursion, 0x777)
> reports on Simulate((Infinite_Recursion, 0x777)
>
> In every case a simulating halt decider reports on what the behavior of
> its simulated input would be if this SHD was swapped for a simulator.


Click here to read the complete article
Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<xZGdnWjVQ-X8kmD_nZ2dnZfqlJzNnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border-2.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-1.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 17 Aug 2022 15:55:13 +0000
Date: Wed, 17 Aug 2022 10:55:29 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<s0-dnfITQe3_32H_nZ2dnZfqlJ_NnZ2d@giganews.com>
<rUXKK.733786$5fVf.382893@fx09.iad> <tdhir4$astl$1@dont-email.me>
<e669a38a-d240-4a92-aa36-07d3ef57b171n@googlegroups.com>
<2uqdnYI1ZK9Zy2H_nZ2dnZfqlJzNnZ2d@giganews.com>
<827c17dc-b5c5-4023-b73c-f77925c56c1an@googlegroups.com>
<u8udnaC_csJhwGH_nZ2dnZfqlJxh4p2d@giganews.com>
<cf36a0c8-68d3-4eae-bcc2-39e36c5b1403n@googlegroups.com>
<sySdnc8OUfRL_2H_nZ2dnZfqlJ9g4p2d@giganews.com>
<afafbc24-9373-4686-ac19-909a06ffaf79n@googlegroups.com>
<c3Sdnf2c2IG_-mH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<2b06c9cb-4cb3-4866-a4ad-a5e9f10a6270n@googlegroups.com>
<h_qdnUg9Jqn282H_nZ2dnZfqlJzNnZ2d@giganews.com>
<92857281-cb53-4ddc-908a-50d2937c403en@googlegroups.com>
<kyCdnWCxIsAqZGH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<772d0a3b-f170-40c0-8abb-6569ae6cc5d5n@googlegroups.com>
<xvydnfdGtIaElWD_nZ2dnZfqlJzNnZ2d@giganews.com>
<0a36df55-771f-4f26-a073-4dc34ac69942n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <0a36df55-771f-4f26-a073-4dc34ac69942n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <xZGdnWjVQ-X8kmD_nZ2dnZfqlJzNnZ2d@giganews.com>
Lines: 202
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-L0bLBOWPDRtW2JnlgZT0/tCj+1flNpbNBCNaEAfEwesuAt8Bos16xtdRYQSvp6zqacIDdeXvw4xFOYV!CIkQWPh7ubEiaV7Bbu+xVI51eUwQvBu7XgBOgJMtt9gJ0i6coTLyQOmoWROZKdhett3bhp+j59g=
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
 by: olcott - Wed, 17 Aug 2022 15:55 UTC

On 8/17/2022 10:35 AM, Dennis Bush wrote:
> On Wednesday, August 17, 2022 at 11:24:34 AM UTC-4, olcott wrote:
>> On 8/17/2022 9:51 AM, Dennis Bush wrote:
>>> On Wednesday, August 17, 2022 at 10:23:17 AM UTC-4, olcott wrote:
>>>> On 8/17/2022 6:40 AM, Dennis Bush wrote:
>>>>> On Wednesday, August 17, 2022 at 12:28:52 AM UTC-4, olcott wrote:
>>>>>> On 8/16/2022 11:02 PM, Dennis Bush wrote:
>>>>>>> On Tuesday, August 16, 2022 at 11:57:51 PM UTC-4, olcott wrote:
>>>>>>>> On 8/16/2022 10:53 PM, Dennis Bush wrote:
>>>>>>>>> On Tuesday, August 16, 2022 at 11:39:32 PM UTC-4, olcott wrote:
>>>>>>>>>> On 8/16/2022 10:23 PM, Dennis Bush wrote:
>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:18:46 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 8/16/2022 9:52 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:47:57 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 8/16/2022 9:34 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:12:55 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 8/16/2022 8:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 8/16/22 9:20 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 8/16/2022 8:10 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 8/16/22 10:27 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:07 AM, Skep Dick wrote:
>>>>>>>>>>>>>>>>>>>>> On Tuesday, 16 August 2022 at 15:55:30 UTC+2, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> The correct and complete x86 emulation of the input to H(P,P) by H
>>>>>>>>>>>>>>>>>>>>>> WOULD
>>>>>>>>>>>>>>>>>>>>>> never stop running.
>>>>>>>>>>>>>>>>>>>>> Sounds like you are stuck in a loop.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Maybe your Decider/Maker should terminate you.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I have been trying to get an honest person to acknowledge the
>>>>>>>>>>>>>>>>>>>> correct software engineering of my system so that we can move on to
>>>>>>>>>>>>>>>>>>>> the next point for a year now. (bot many honest people here, mostly
>>>>>>>>>>>>>>>>>>>> trolls).
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The problem is that what you say ISN'T CORRECT software engineering.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You use the wrong definition of things and incorrect assumptions
>>>>>>>>>>>>>>>>>>> about thing, so it just isn't true.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H(P,P) does correctly predict that its correct and complete x86
>>>>>>>>>>>>>>>>>>>> emulation of its input would never stop running, thus does correctly
>>>>>>>>>>>>>>>>>>>> reject this input as non-halting.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Nope. And in fact, you even acknoldge it doesn't but just don't see it.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So you are saying that the correct and complete x86 emulation by
>>>>>>>>>>>>>>>>>> H(P,P) of its input WOULD STOP RUNNING?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, I am saying that you H doesn't do a correct and complete emulation
>>>>>>>>>>>>>>>>> of its input, and thus to say it did is just a LIE.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I said that H correctly predicts what the behavior of its correct and
>>>>>>>>>>>>>>>> complete x86 emulation of H(P,P) would be
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The fixed source code of H (and everything it calls) that aborts is Ha. Ha *always* aborts Pa, so "the correct and complete simulation of Ha(Pa,Pa)" does not exist, just like the shoes that Napoleon wore on Mars do not exist.
>>>>>>>>>>>>>> So you are another brain dead moron the believes it is utterly
>>>>>>>>>>>>>> impossible for H to correctly predict that its correct and complete x86
>>>>>>>>>>>>>> emulation of its input would never stop running unless H actually
>>>>>>>>>>>>>> performed a correct and complete emulation of its input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The correct and complete emulation of Ha(Pa,Pa) doesn't exist,
>>>>>>>>>>>> Neither does the correct and complete emulation of Infinite_Loop()
>>>>>>>>>>>
>>>>>>>>>>> Yes it does. If you simulate Infinite_Loop(), it won't halt. But if you run Ha(Pa,Pa), it won't do a correct and complete simulation because it aborts.
>>>>>>>>>> When you run H0((u32)Infinite_Loop)
>>>>>>>>>> "it won't do a correct and complete simulation because it aborts"
>>>>>>>>>> How long are you going to keep the head game up?
>>>>>>>>>
>>>>>>>>> That you don't understand what I'm saying doesn't make it a head game.
>>>>>>>>>
>>>>>>>> You reject Ha(Pa,Pa) on this basis
>>>>>>>> run Ha(Pa,Pa), it won't do a correct and complete simulation because it
>>>>>>>> aborts.
>>>>>>>> Yet accept P0(Infinite_Loop), on the same basis
>>>>>>>> it won't do a correct and complete simulation because it aborts.
>>>>>>>> ∴ You are playing head games.
>>>>>>>
>>>>>>> What does P0 do? Does it abort? If so, then yes P0(Infinite_Loop) doesn't do a correct and complete simulation because it aborts, so it's invalid to predict what the correct and complete simulation of P0(Infinite_Loop) would do.
>>>>>>>
>>>>>>> On the other hand, UTM(Infinite_Loop) does do a correct and complete simulation, so it *is* valid to predict what it will do.
>>>>>>>
>>>>>> In other words you are not bright enough to see that it is very easy for
>>>>>> H0 to recognize an infinite loop would never halt in a finite number of
>>>>>> steps of simulation?
>>>>>
>>>>> I'm saying that H0 can see that the correct and complete simulation performed by UTM(Infinite_Loop) does not halt. It does not and cannot see that the correct and complete simulation performed by H0(Infinite_Loop) (i.e. your basis for correctness) does not halt because H0 does not perform a correct and complete simulation.
>>>>>
>>>> This is what I mean by H evaluating what its correct and complete
>>>> simulation of its input would be:
>>>>
>>>> void P(ptr x)
>>>> {
>>>> int Halt_Status = Simulate(x, x);
>>>> if (Halt_Status)
>>>> HERE: goto HERE;
>>>> return;
>>>> }
>>>>
>>>> Although H itself does not perform a correct and complete simulation of
>>>> non-halting inputs H does correctly predict that such a simulation would
>>>> never halt.
>>>
>>> You changed the input from Pa to Pn.
>>>
>>> So you're again saying that Ha(Pa,Pa) reports the halt status of the non-input Pn(Pn) instead of Pa(Pa) as it is required to:
>>>
>> H0(Infinite_Loop)
>> reports on Simulate(Infinite_Loop)
>>
>> H(Infinite_Recursion, 0x777)
>> reports on Simulate((Infinite_Recursion, 0x777)
>>
>> In every case a simulating halt decider reports on what the behavior of
>> its simulated input would be if this SHD was swapped for a simulator.
>
> And in the case of Ha(Pa,Pa) you change the input in doing so which is not allowed. Remember, what is being decided on is the FIXED source code of Pa and everything it calls, which includes the FIXED source code of Ha and everything it calls.


Click here to read the complete article
Re: Here is what a computer scientist that has been published in CACM said about my work [competence?]

<43abc3f8-279b-4eca-ac54-dbcf7b276db9n@googlegroups.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
X-Received: by 2002:a05:620a:d8a:b0:6b8:5bac:24c1 with SMTP id q10-20020a05620a0d8a00b006b85bac24c1mr19309886qkl.176.1660752414833;
Wed, 17 Aug 2022 09:06:54 -0700 (PDT)
X-Received: by 2002:a0d:ef81:0:b0:329:b9f0:7960 with SMTP id
y123-20020a0def81000000b00329b9f07960mr22112104ywe.248.1660752414379; Wed, 17
Aug 2022 09:06:54 -0700 (PDT)
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Wed, 17 Aug 2022 09:06:54 -0700 (PDT)
In-Reply-To: <xZGdnWjVQ-X8kmD_nZ2dnZfqlJzNnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=98.110.86.97; posting-account=ejFcQgoAAACAt5i0VbkATkR2ACWdgADD
NNTP-Posting-Host: 98.110.86.97
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<s0-dnfITQe3_32H_nZ2dnZfqlJ_NnZ2d@giganews.com> <rUXKK.733786$5fVf.382893@fx09.iad>
<tdhir4$astl$1@dont-email.me> <e669a38a-d240-4a92-aa36-07d3ef57b171n@googlegroups.com>
<2uqdnYI1ZK9Zy2H_nZ2dnZfqlJzNnZ2d@giganews.com> <827c17dc-b5c5-4023-b73c-f77925c56c1an@googlegroups.com>
<u8udnaC_csJhwGH_nZ2dnZfqlJxh4p2d@giganews.com> <cf36a0c8-68d3-4eae-bcc2-39e36c5b1403n@googlegroups.com>
<sySdnc8OUfRL_2H_nZ2dnZfqlJ9g4p2d@giganews.com> <afafbc24-9373-4686-ac19-909a06ffaf79n@googlegroups.com>
<c3Sdnf2c2IG_-mH_nZ2dnZfqlJ_NnZ2d@giganews.com> <2b06c9cb-4cb3-4866-a4ad-a5e9f10a6270n@googlegroups.com>
<h_qdnUg9Jqn282H_nZ2dnZfqlJzNnZ2d@giganews.com> <92857281-cb53-4ddc-908a-50d2937c403en@googlegroups.com>
<kyCdnWCxIsAqZGH_nZ2dnZfqlJ_NnZ2d@giganews.com> <772d0a3b-f170-40c0-8abb-6569ae6cc5d5n@googlegroups.com>
<xvydnfdGtIaElWD_nZ2dnZfqlJzNnZ2d@giganews.com> <0a36df55-771f-4f26-a073-4dc34ac69942n@googlegroups.com>
<xZGdnWjVQ-X8kmD_nZ2dnZfqlJzNnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <43abc3f8-279b-4eca-ac54-dbcf7b276db9n@googlegroups.com>
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
From: dbush.mo...@gmail.com (Dennis Bush)
Injection-Date: Wed, 17 Aug 2022 16:06:54 +0000
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
X-Received-Bytes: 13676
 by: Dennis Bush - Wed, 17 Aug 2022 16:06 UTC

On Wednesday, August 17, 2022 at 11:55:36 AM UTC-4, olcott wrote:
> On 8/17/2022 10:35 AM, Dennis Bush wrote:
> > On Wednesday, August 17, 2022 at 11:24:34 AM UTC-4, olcott wrote:
> >> On 8/17/2022 9:51 AM, Dennis Bush wrote:
> >>> On Wednesday, August 17, 2022 at 10:23:17 AM UTC-4, olcott wrote:
> >>>> On 8/17/2022 6:40 AM, Dennis Bush wrote:
> >>>>> On Wednesday, August 17, 2022 at 12:28:52 AM UTC-4, olcott wrote:
> >>>>>> On 8/16/2022 11:02 PM, Dennis Bush wrote:
> >>>>>>> On Tuesday, August 16, 2022 at 11:57:51 PM UTC-4, olcott wrote:
> >>>>>>>> On 8/16/2022 10:53 PM, Dennis Bush wrote:
> >>>>>>>>> On Tuesday, August 16, 2022 at 11:39:32 PM UTC-4, olcott wrote:
> >>>>>>>>>> On 8/16/2022 10:23 PM, Dennis Bush wrote:
> >>>>>>>>>>> On Tuesday, August 16, 2022 at 11:18:46 PM UTC-4, olcott wrote:
> >>>>>>>>>>>> On 8/16/2022 9:52 PM, Dennis Bush wrote:
> >>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:47:57 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>> On 8/16/2022 9:34 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:12:55 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>> On 8/16/2022 8:55 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>> On 8/16/22 9:20 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>> On 8/16/2022 8:10 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>> On 8/16/22 10:27 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:07 AM, Skep Dick wrote:
> >>>>>>>>>>>>>>>>>>>>> On Tuesday, 16 August 2022 at 15:55:30 UTC+2, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> The correct and complete x86 emulation of the input to H(P,P) by H
> >>>>>>>>>>>>>>>>>>>>>> WOULD
> >>>>>>>>>>>>>>>>>>>>>> never stop running.
> >>>>>>>>>>>>>>>>>>>>> Sounds like you are stuck in a loop.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> Maybe your Decider/Maker should terminate you.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> I have been trying to get an honest person to acknowledge the
> >>>>>>>>>>>>>>>>>>>> correct software engineering of my system so that we can move on to
> >>>>>>>>>>>>>>>>>>>> the next point for a year now. (bot many honest people here, mostly
> >>>>>>>>>>>>>>>>>>>> trolls).
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> The problem is that what you say ISN'T CORRECT software engineering.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> You use the wrong definition of things and incorrect assumptions
> >>>>>>>>>>>>>>>>>>> about thing, so it just isn't true.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> H(P,P) does correctly predict that its correct and complete x86
> >>>>>>>>>>>>>>>>>>>> emulation of its input would never stop running, thus does correctly
> >>>>>>>>>>>>>>>>>>>> reject this input as non-halting.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> Nope. And in fact, you even acknoldge it doesn't but just don't see it.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> So you are saying that the correct and complete x86 emulation by
> >>>>>>>>>>>>>>>>>> H(P,P) of its input WOULD STOP RUNNING?
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> No, I am saying that you H doesn't do a correct and complete emulation
> >>>>>>>>>>>>>>>>> of its input, and thus to say it did is just a LIE.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> I said that H correctly predicts what the behavior of its correct and
> >>>>>>>>>>>>>>>> complete x86 emulation of H(P,P) would be
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> The fixed source code of H (and everything it calls) that aborts is Ha. Ha *always* aborts Pa, so "the correct and complete simulation of Ha(Pa,Pa)" does not exist, just like the shoes that Napoleon wore on Mars do not exist.
> >>>>>>>>>>>>>> So you are another brain dead moron the believes it is utterly
> >>>>>>>>>>>>>> impossible for H to correctly predict that its correct and complete x86
> >>>>>>>>>>>>>> emulation of its input would never stop running unless H actually
> >>>>>>>>>>>>>> performed a correct and complete emulation of its input.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> The correct and complete emulation of Ha(Pa,Pa) doesn't exist,
> >>>>>>>>>>>> Neither does the correct and complete emulation of Infinite_Loop()
> >>>>>>>>>>>
> >>>>>>>>>>> Yes it does. If you simulate Infinite_Loop(), it won't halt. But if you run Ha(Pa,Pa), it won't do a correct and complete simulation because it aborts.
> >>>>>>>>>> When you run H0((u32)Infinite_Loop)
> >>>>>>>>>> "it won't do a correct and complete simulation because it aborts"
> >>>>>>>>>> How long are you going to keep the head game up?
> >>>>>>>>>
> >>>>>>>>> That you don't understand what I'm saying doesn't make it a head game.
> >>>>>>>>>
> >>>>>>>> You reject Ha(Pa,Pa) on this basis
> >>>>>>>> run Ha(Pa,Pa), it won't do a correct and complete simulation because it
> >>>>>>>> aborts.
> >>>>>>>> Yet accept P0(Infinite_Loop), on the same basis
> >>>>>>>> it won't do a correct and complete simulation because it aborts.
> >>>>>>>> ∴ You are playing head games.
> >>>>>>>
> >>>>>>> What does P0 do? Does it abort? If so, then yes P0(Infinite_Loop) doesn't do a correct and complete simulation because it aborts, so it's invalid to predict what the correct and complete simulation of P0(Infinite_Loop) would do.
> >>>>>>>
> >>>>>>> On the other hand, UTM(Infinite_Loop) does do a correct and complete simulation, so it *is* valid to predict what it will do.
> >>>>>>>
> >>>>>> In other words you are not bright enough to see that it is very easy for
> >>>>>> H0 to recognize an infinite loop would never halt in a finite number of
> >>>>>> steps of simulation?
> >>>>>
> >>>>> I'm saying that H0 can see that the correct and complete simulation performed by UTM(Infinite_Loop) does not halt. It does not and cannot see that the correct and complete simulation performed by H0(Infinite_Loop) (i.e. your basis for correctness) does not halt because H0 does not perform a correct and complete simulation.
> >>>>>
> >>>> This is what I mean by H evaluating what its correct and complete
> >>>> simulation of its input would be:
> >>>>
> >>>> void P(ptr x)
> >>>> {
> >>>> int Halt_Status = Simulate(x, x);
> >>>> if (Halt_Status)
> >>>> HERE: goto HERE;
> >>>> return;
> >>>> }
> >>>>
> >>>> Although H itself does not perform a correct and complete simulation of
> >>>> non-halting inputs H does correctly predict that such a simulation would
> >>>> never halt.
> >>>
> >>> You changed the input from Pa to Pn.
> >>>
> >>> So you're again saying that Ha(Pa,Pa) reports the halt status of the non-input Pn(Pn) instead of Pa(Pa) as it is required to:
> >>>
> >> H0(Infinite_Loop)
> >> reports on Simulate(Infinite_Loop)
> >>
> >> H(Infinite_Recursion, 0x777)
> >> reports on Simulate((Infinite_Recursion, 0x777)
> >>
> >> In every case a simulating halt decider reports on what the behavior of
> >> its simulated input would be if this SHD was swapped for a simulator.
> >
> > And in the case of Ha(Pa,Pa) you change the input in doing so which is not allowed. Remember, what is being decided on is the FIXED source code of Pa and everything it calls, which includes the FIXED source code of Ha and everything it calls.
> THIS JUST SEEMS OVER YOUR HEAD.
> H correctly determines that its input would never halt by correctly
> predicting that its input would never halt if H never aborted its
> simulation of this input.


Click here to read the complete article
Re: Here is what a computer scientist that has been published in CACM said about my work [stupid]

<iMecnScwOYKViGD_nZ2dnZfqlJ_NnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!1.us.feeder.erje.net!feeder.erje.net!border-1.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 17 Aug 2022 16:19:20 +0000
Date: Wed, 17 Aug 2022 11:19:42 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [stupid]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<tdhir4$astl$1@dont-email.me>
<e669a38a-d240-4a92-aa36-07d3ef57b171n@googlegroups.com>
<2uqdnYI1ZK9Zy2H_nZ2dnZfqlJzNnZ2d@giganews.com>
<827c17dc-b5c5-4023-b73c-f77925c56c1an@googlegroups.com>
<u8udnaC_csJhwGH_nZ2dnZfqlJxh4p2d@giganews.com>
<cf36a0c8-68d3-4eae-bcc2-39e36c5b1403n@googlegroups.com>
<sySdnc8OUfRL_2H_nZ2dnZfqlJ9g4p2d@giganews.com>
<afafbc24-9373-4686-ac19-909a06ffaf79n@googlegroups.com>
<c3Sdnf2c2IG_-mH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<2b06c9cb-4cb3-4866-a4ad-a5e9f10a6270n@googlegroups.com>
<h_qdnUg9Jqn282H_nZ2dnZfqlJzNnZ2d@giganews.com>
<92857281-cb53-4ddc-908a-50d2937c403en@googlegroups.com>
<kyCdnWCxIsAqZGH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<772d0a3b-f170-40c0-8abb-6569ae6cc5d5n@googlegroups.com>
<xvydnfdGtIaElWD_nZ2dnZfqlJzNnZ2d@giganews.com>
<0a36df55-771f-4f26-a073-4dc34ac69942n@googlegroups.com>
<xZGdnWjVQ-X8kmD_nZ2dnZfqlJzNnZ2d@giganews.com>
<43abc3f8-279b-4eca-ac54-dbcf7b276db9n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <43abc3f8-279b-4eca-ac54-dbcf7b276db9n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <iMecnScwOYKViGD_nZ2dnZfqlJ_NnZ2d@giganews.com>
Lines: 155
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-rT0rvzo6hpuMETfCd+1MK4yGksIKuIHEaNyK70RWHlUERZzt1D+XmHbetMWG5DrLVm+DjmxPNo2mMxI!yCd2o6DEHoirV143WAno8vbVJiLCoWOZoLJAJoptvPQFeQ4PYOlU2NgExnY7WlW0Fq+xtGXIkl8=
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
 by: olcott - Wed, 17 Aug 2022 16:19 UTC

On 8/17/2022 11:06 AM, Dennis Bush wrote:
> On Wednesday, August 17, 2022 at 11:55:36 AM UTC-4, olcott wrote:
>> On 8/17/2022 10:35 AM, Dennis Bush wrote:
>>> On Wednesday, August 17, 2022 at 11:24:34 AM UTC-4, olcott wrote:
>>>> On 8/17/2022 9:51 AM, Dennis Bush wrote:
>>>>> On Wednesday, August 17, 2022 at 10:23:17 AM UTC-4, olcott wrote:
>>>>>> On 8/17/2022 6:40 AM, Dennis Bush wrote:
>>>>>>> On Wednesday, August 17, 2022 at 12:28:52 AM UTC-4, olcott wrote:
>>>>>>>> On 8/16/2022 11:02 PM, Dennis Bush wrote:
>>>>>>>>> On Tuesday, August 16, 2022 at 11:57:51 PM UTC-4, olcott wrote:
>>>>>>>>>> On 8/16/2022 10:53 PM, Dennis Bush wrote:
>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:39:32 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 8/16/2022 10:23 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:18:46 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 8/16/2022 9:52 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:47:57 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 8/16/2022 9:34 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:12:55 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>> On 8/16/2022 8:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 8/16/22 9:20 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 8/16/2022 8:10 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 8/16/22 10:27 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:07 AM, Skep Dick wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, 16 August 2022 at 15:55:30 UTC+2, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete x86 emulation of the input to H(P,P) by H
>>>>>>>>>>>>>>>>>>>>>>>> WOULD
>>>>>>>>>>>>>>>>>>>>>>>> never stop running.
>>>>>>>>>>>>>>>>>>>>>>> Sounds like you are stuck in a loop.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Maybe your Decider/Maker should terminate you.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> I have been trying to get an honest person to acknowledge the
>>>>>>>>>>>>>>>>>>>>>> correct software engineering of my system so that we can move on to
>>>>>>>>>>>>>>>>>>>>>> the next point for a year now. (bot many honest people here, mostly
>>>>>>>>>>>>>>>>>>>>>> trolls).
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The problem is that what you say ISN'T CORRECT software engineering.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You use the wrong definition of things and incorrect assumptions
>>>>>>>>>>>>>>>>>>>>> about thing, so it just isn't true.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> H(P,P) does correctly predict that its correct and complete x86
>>>>>>>>>>>>>>>>>>>>>> emulation of its input would never stop running, thus does correctly
>>>>>>>>>>>>>>>>>>>>>> reject this input as non-halting.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Nope. And in fact, you even acknoldge it doesn't but just don't see it.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> So you are saying that the correct and complete x86 emulation by
>>>>>>>>>>>>>>>>>>>> H(P,P) of its input WOULD STOP RUNNING?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No, I am saying that you H doesn't do a correct and complete emulation
>>>>>>>>>>>>>>>>>>> of its input, and thus to say it did is just a LIE.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I said that H correctly predicts what the behavior of its correct and
>>>>>>>>>>>>>>>>>> complete x86 emulation of H(P,P) would be
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The fixed source code of H (and everything it calls) that aborts is Ha. Ha *always* aborts Pa, so "the correct and complete simulation of Ha(Pa,Pa)" does not exist, just like the shoes that Napoleon wore on Mars do not exist.
>>>>>>>>>>>>>>>> So you are another brain dead moron the believes it is utterly
>>>>>>>>>>>>>>>> impossible for H to correctly predict that its correct and complete x86
>>>>>>>>>>>>>>>> emulation of its input would never stop running unless H actually
>>>>>>>>>>>>>>>> performed a correct and complete emulation of its input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The correct and complete emulation of Ha(Pa,Pa) doesn't exist,
>>>>>>>>>>>>>> Neither does the correct and complete emulation of Infinite_Loop()
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes it does. If you simulate Infinite_Loop(), it won't halt. But if you run Ha(Pa,Pa), it won't do a correct and complete simulation because it aborts.
>>>>>>>>>>>> When you run H0((u32)Infinite_Loop)
>>>>>>>>>>>> "it won't do a correct and complete simulation because it aborts"
>>>>>>>>>>>> How long are you going to keep the head game up?
>>>>>>>>>>>
>>>>>>>>>>> That you don't understand what I'm saying doesn't make it a head game.
>>>>>>>>>>>
>>>>>>>>>> You reject Ha(Pa,Pa) on this basis
>>>>>>>>>> run Ha(Pa,Pa), it won't do a correct and complete simulation because it
>>>>>>>>>> aborts.
>>>>>>>>>> Yet accept P0(Infinite_Loop), on the same basis
>>>>>>>>>> it won't do a correct and complete simulation because it aborts.
>>>>>>>>>> ∴ You are playing head games.
>>>>>>>>>
>>>>>>>>> What does P0 do? Does it abort? If so, then yes P0(Infinite_Loop) doesn't do a correct and complete simulation because it aborts, so it's invalid to predict what the correct and complete simulation of P0(Infinite_Loop) would do.
>>>>>>>>>
>>>>>>>>> On the other hand, UTM(Infinite_Loop) does do a correct and complete simulation, so it *is* valid to predict what it will do.
>>>>>>>>>
>>>>>>>> In other words you are not bright enough to see that it is very easy for
>>>>>>>> H0 to recognize an infinite loop would never halt in a finite number of
>>>>>>>> steps of simulation?
>>>>>>>
>>>>>>> I'm saying that H0 can see that the correct and complete simulation performed by UTM(Infinite_Loop) does not halt. It does not and cannot see that the correct and complete simulation performed by H0(Infinite_Loop) (i.e. your basis for correctness) does not halt because H0 does not perform a correct and complete simulation.
>>>>>>>
>>>>>> This is what I mean by H evaluating what its correct and complete
>>>>>> simulation of its input would be:
>>>>>>
>>>>>> void P(ptr x)
>>>>>> {
>>>>>> int Halt_Status = Simulate(x, x);
>>>>>> if (Halt_Status)
>>>>>> HERE: goto HERE;
>>>>>> return;
>>>>>> }
>>>>>>
>>>>>> Although H itself does not perform a correct and complete simulation of
>>>>>> non-halting inputs H does correctly predict that such a simulation would
>>>>>> never halt.
>>>>>
>>>>> You changed the input from Pa to Pn.
>>>>>
>>>>> So you're again saying that Ha(Pa,Pa) reports the halt status of the non-input Pn(Pn) instead of Pa(Pa) as it is required to:
>>>>>
>>>> H0(Infinite_Loop)
>>>> reports on Simulate(Infinite_Loop)
>>>>
>>>> H(Infinite_Recursion, 0x777)
>>>> reports on Simulate((Infinite_Recursion, 0x777)
>>>>
>>>> In every case a simulating halt decider reports on what the behavior of
>>>> its simulated input would be if this SHD was swapped for a simulator.
>>>
>>> And in the case of Ha(Pa,Pa) you change the input in doing so which is not allowed. Remember, what is being decided on is the FIXED source code of Pa and everything it calls, which includes the FIXED source code of Ha and everything it calls.
>> THIS JUST SEEMS OVER YOUR HEAD.
>> H correctly determines that its input would never halt by correctly
>> predicting that its input would never halt if H never aborted its
>> simulation of this input.
>
> Which is not what it is required to do if it claims to be a halt decider:
>
> For *any* algorithm X and input Y:
> H(X,Y)==1 if and only if X(Y) halts, and
> H(X,Y)==0 if and only if X(Y) does not halt
>


Click here to read the complete article
Re: Here is what a computer scientist that has been published in CACM said about my work [stupid]

<68e43e9f-8ac6-45c8-ae2d-54cf74c76787n@googlegroups.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
X-Received: by 2002:ac8:5fd6:0:b0:343:4b4:1022 with SMTP id k22-20020ac85fd6000000b0034304b41022mr23525618qta.616.1660753559738;
Wed, 17 Aug 2022 09:25:59 -0700 (PDT)
X-Received: by 2002:a25:7704:0:b0:692:6184:a56b with SMTP id
s4-20020a257704000000b006926184a56bmr219891ybc.16.1660753558245; Wed, 17 Aug
2022 09:25:58 -0700 (PDT)
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border-2.nntp.ord.giganews.com!nntp.giganews.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Wed, 17 Aug 2022 09:25:58 -0700 (PDT)
In-Reply-To: <iMecnScwOYKViGD_nZ2dnZfqlJ_NnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=98.110.86.97; posting-account=ejFcQgoAAACAt5i0VbkATkR2ACWdgADD
NNTP-Posting-Host: 98.110.86.97
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<tdhir4$astl$1@dont-email.me> <e669a38a-d240-4a92-aa36-07d3ef57b171n@googlegroups.com>
<2uqdnYI1ZK9Zy2H_nZ2dnZfqlJzNnZ2d@giganews.com> <827c17dc-b5c5-4023-b73c-f77925c56c1an@googlegroups.com>
<u8udnaC_csJhwGH_nZ2dnZfqlJxh4p2d@giganews.com> <cf36a0c8-68d3-4eae-bcc2-39e36c5b1403n@googlegroups.com>
<sySdnc8OUfRL_2H_nZ2dnZfqlJ9g4p2d@giganews.com> <afafbc24-9373-4686-ac19-909a06ffaf79n@googlegroups.com>
<c3Sdnf2c2IG_-mH_nZ2dnZfqlJ_NnZ2d@giganews.com> <2b06c9cb-4cb3-4866-a4ad-a5e9f10a6270n@googlegroups.com>
<h_qdnUg9Jqn282H_nZ2dnZfqlJzNnZ2d@giganews.com> <92857281-cb53-4ddc-908a-50d2937c403en@googlegroups.com>
<kyCdnWCxIsAqZGH_nZ2dnZfqlJ_NnZ2d@giganews.com> <772d0a3b-f170-40c0-8abb-6569ae6cc5d5n@googlegroups.com>
<xvydnfdGtIaElWD_nZ2dnZfqlJzNnZ2d@giganews.com> <0a36df55-771f-4f26-a073-4dc34ac69942n@googlegroups.com>
<xZGdnWjVQ-X8kmD_nZ2dnZfqlJzNnZ2d@giganews.com> <43abc3f8-279b-4eca-ac54-dbcf7b276db9n@googlegroups.com>
<iMecnScwOYKViGD_nZ2dnZfqlJ_NnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <68e43e9f-8ac6-45c8-ae2d-54cf74c76787n@googlegroups.com>
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [stupid]
From: dbush.mo...@gmail.com (Dennis Bush)
Injection-Date: Wed, 17 Aug 2022 16:25:59 +0000
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
Lines: 224
 by: Dennis Bush - Wed, 17 Aug 2022 16:25 UTC

On Wednesday, August 17, 2022 at 12:19:51 PM UTC-4, olcott wrote:
> On 8/17/2022 11:06 AM, Dennis Bush wrote:
> > On Wednesday, August 17, 2022 at 11:55:36 AM UTC-4, olcott wrote:
> >> On 8/17/2022 10:35 AM, Dennis Bush wrote:
> >>> On Wednesday, August 17, 2022 at 11:24:34 AM UTC-4, olcott wrote:
> >>>> On 8/17/2022 9:51 AM, Dennis Bush wrote:
> >>>>> On Wednesday, August 17, 2022 at 10:23:17 AM UTC-4, olcott wrote:
> >>>>>> On 8/17/2022 6:40 AM, Dennis Bush wrote:
> >>>>>>> On Wednesday, August 17, 2022 at 12:28:52 AM UTC-4, olcott wrote:
> >>>>>>>> On 8/16/2022 11:02 PM, Dennis Bush wrote:
> >>>>>>>>> On Tuesday, August 16, 2022 at 11:57:51 PM UTC-4, olcott wrote:
> >>>>>>>>>> On 8/16/2022 10:53 PM, Dennis Bush wrote:
> >>>>>>>>>>> On Tuesday, August 16, 2022 at 11:39:32 PM UTC-4, olcott wrote:
> >>>>>>>>>>>> On 8/16/2022 10:23 PM, Dennis Bush wrote:
> >>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:18:46 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>> On 8/16/2022 9:52 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:47:57 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>> On 8/16/2022 9:34 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:12:55 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>> On 8/16/2022 8:55 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>> On 8/16/22 9:20 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 8/16/2022 8:10 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>> On 8/16/22 10:27 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:07 AM, Skep Dick wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On Tuesday, 16 August 2022 at 15:55:30 UTC+2, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> The correct and complete x86 emulation of the input to H(P,P) by H
> >>>>>>>>>>>>>>>>>>>>>>>> WOULD
> >>>>>>>>>>>>>>>>>>>>>>>> never stop running.
> >>>>>>>>>>>>>>>>>>>>>>> Sounds like you are stuck in a loop.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> Maybe your Decider/Maker should terminate you.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> I have been trying to get an honest person to acknowledge the
> >>>>>>>>>>>>>>>>>>>>>> correct software engineering of my system so that we can move on to
> >>>>>>>>>>>>>>>>>>>>>> the next point for a year now. (bot many honest people here, mostly
> >>>>>>>>>>>>>>>>>>>>>> trolls).
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> The problem is that what you say ISN'T CORRECT software engineering.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> You use the wrong definition of things and incorrect assumptions
> >>>>>>>>>>>>>>>>>>>>> about thing, so it just isn't true.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> H(P,P) does correctly predict that its correct and complete x86
> >>>>>>>>>>>>>>>>>>>>>> emulation of its input would never stop running, thus does correctly
> >>>>>>>>>>>>>>>>>>>>>> reject this input as non-halting.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> Nope. And in fact, you even acknoldge it doesn't but just don't see it.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> So you are saying that the correct and complete x86 emulation by
> >>>>>>>>>>>>>>>>>>>> H(P,P) of its input WOULD STOP RUNNING?
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> No, I am saying that you H doesn't do a correct and complete emulation
> >>>>>>>>>>>>>>>>>>> of its input, and thus to say it did is just a LIE.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> I said that H correctly predicts what the behavior of its correct and
> >>>>>>>>>>>>>>>>>> complete x86 emulation of H(P,P) would be
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> The fixed source code of H (and everything it calls) that aborts is Ha. Ha *always* aborts Pa, so "the correct and complete simulation of Ha(Pa,Pa)" does not exist, just like the shoes that Napoleon wore on Mars do not exist.
> >>>>>>>>>>>>>>>> So you are another brain dead moron the believes it is utterly
> >>>>>>>>>>>>>>>> impossible for H to correctly predict that its correct and complete x86
> >>>>>>>>>>>>>>>> emulation of its input would never stop running unless H actually
> >>>>>>>>>>>>>>>> performed a correct and complete emulation of its input.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> The correct and complete emulation of Ha(Pa,Pa) doesn't exist,
> >>>>>>>>>>>>>> Neither does the correct and complete emulation of Infinite_Loop()
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Yes it does. If you simulate Infinite_Loop(), it won't halt.. But if you run Ha(Pa,Pa), it won't do a correct and complete simulation because it aborts.
> >>>>>>>>>>>> When you run H0((u32)Infinite_Loop)
> >>>>>>>>>>>> "it won't do a correct and complete simulation because it aborts"
> >>>>>>>>>>>> How long are you going to keep the head game up?
> >>>>>>>>>>>
> >>>>>>>>>>> That you don't understand what I'm saying doesn't make it a head game.
> >>>>>>>>>>>
> >>>>>>>>>> You reject Ha(Pa,Pa) on this basis
> >>>>>>>>>> run Ha(Pa,Pa), it won't do a correct and complete simulation because it
> >>>>>>>>>> aborts.
> >>>>>>>>>> Yet accept P0(Infinite_Loop), on the same basis
> >>>>>>>>>> it won't do a correct and complete simulation because it aborts.
> >>>>>>>>>> ∴ You are playing head games.
> >>>>>>>>>
> >>>>>>>>> What does P0 do? Does it abort? If so, then yes P0(Infinite_Loop) doesn't do a correct and complete simulation because it aborts, so it's invalid to predict what the correct and complete simulation of P0(Infinite_Loop) would do.
> >>>>>>>>>
> >>>>>>>>> On the other hand, UTM(Infinite_Loop) does do a correct and complete simulation, so it *is* valid to predict what it will do.
> >>>>>>>>>
> >>>>>>>> In other words you are not bright enough to see that it is very easy for
> >>>>>>>> H0 to recognize an infinite loop would never halt in a finite number of
> >>>>>>>> steps of simulation?
> >>>>>>>
> >>>>>>> I'm saying that H0 can see that the correct and complete simulation performed by UTM(Infinite_Loop) does not halt. It does not and cannot see that the correct and complete simulation performed by H0(Infinite_Loop) (i.e. your basis for correctness) does not halt because H0 does not perform a correct and complete simulation.
> >>>>>>>
> >>>>>> This is what I mean by H evaluating what its correct and complete
> >>>>>> simulation of its input would be:
> >>>>>>
> >>>>>> void P(ptr x)
> >>>>>> {
> >>>>>> int Halt_Status = Simulate(x, x);
> >>>>>> if (Halt_Status)
> >>>>>> HERE: goto HERE;
> >>>>>> return;
> >>>>>> }
> >>>>>>
> >>>>>> Although H itself does not perform a correct and complete simulation of
> >>>>>> non-halting inputs H does correctly predict that such a simulation would
> >>>>>> never halt.
> >>>>>
> >>>>> You changed the input from Pa to Pn.
> >>>>>
> >>>>> So you're again saying that Ha(Pa,Pa) reports the halt status of the non-input Pn(Pn) instead of Pa(Pa) as it is required to:
> >>>>>
> >>>> H0(Infinite_Loop)
> >>>> reports on Simulate(Infinite_Loop)
> >>>>
> >>>> H(Infinite_Recursion, 0x777)
> >>>> reports on Simulate((Infinite_Recursion, 0x777)
> >>>>
> >>>> In every case a simulating halt decider reports on what the behavior of
> >>>> its simulated input would be if this SHD was swapped for a simulator..
> >>>
> >>> And in the case of Ha(Pa,Pa) you change the input in doing so which is not allowed. Remember, what is being decided on is the FIXED source code of Pa and everything it calls, which includes the FIXED source code of Ha and everything it calls.
> >> THIS JUST SEEMS OVER YOUR HEAD.
> >> H correctly determines that its input would never halt by correctly
> >> predicting that its input would never halt if H never aborted its
> >> simulation of this input.
> >
> > Which is not what it is required to do if it claims to be a halt decider:
> >
> > For *any* algorithm X and input Y:
> > H(X,Y)==1 if and only if X(Y) halts, and
> > H(X,Y)==0 if and only if X(Y) does not halt
> >
> This is based on the false assumption that the actual behavior of the
> actual input is the same behavior as X(Y).


Click here to read the complete article
Re: Here is what a computer scientist that has been published in CACM said about my work [stupid]

<0uWcnYwdfYD2gGD_nZ2dnZfqlJ_NnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!feeder.usenetexpress.com!tr2.iad1.usenetexpress.com!69.80.99.14.MISMATCH!border-1.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 17 Aug 2022 16:55:07 +0000
Date: Wed, 17 Aug 2022 11:55:29 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Thunderbird/91.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM said about my work [stupid]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com> <827c17dc-b5c5-4023-b73c-f77925c56c1an@googlegroups.com> <u8udnaC_csJhwGH_nZ2dnZfqlJxh4p2d@giganews.com> <cf36a0c8-68d3-4eae-bcc2-39e36c5b1403n@googlegroups.com> <sySdnc8OUfRL_2H_nZ2dnZfqlJ9g4p2d@giganews.com> <afafbc24-9373-4686-ac19-909a06ffaf79n@googlegroups.com> <c3Sdnf2c2IG_-mH_nZ2dnZfqlJ_NnZ2d@giganews.com> <2b06c9cb-4cb3-4866-a4ad-a5e9f10a6270n@googlegroups.com> <h_qdnUg9Jqn282H_nZ2dnZfqlJzNnZ2d@giganews.com> <92857281-cb53-4ddc-908a-50d2937c403en@googlegroups.com> <kyCdnWCxIsAqZGH_nZ2dnZfqlJ_NnZ2d@giganews.com> <772d0a3b-f170-40c0-8abb-6569ae6cc5d5n@googlegroups.com> <xvydnfdGtIaElWD_nZ2dnZfqlJzNnZ2d@giganews.com> <0a36df55-771f-4f26-a073-4dc34ac69942n@googlegroups.com> <xZGdnWjVQ-X8kmD_nZ2dnZfqlJzNnZ2d@giganews.com> <43abc3f8-279b-4eca-ac54-dbcf7b276db9n@googlegroups.com> <iMecnScwOYKViGD_nZ2dnZfqlJ_NnZ2d@giganews.com> <68e43e9f-8ac6-45c8-ae2d-54cf74c76787n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <68e43e9f-8ac6-45c8-ae2d-54cf74c76787n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <0uWcnYwdfYD2gGD_nZ2dnZfqlJ_NnZ2d@giganews.com>
Lines: 154
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-MGLJUvAumS8jp/U2dX8UMGz0/3h+T0mOoeh3xx0VOUx1uyf4eF9c0xvgDxJkpJFqP2eymJjyE+Raudo!/3iEXSOKOg9QQDAx2J9FsF8WX0U4qsUIYLb3xjfB6EdYKf5J6oxeZq0oj9lBrUxeAK2iuMKrHVQ=
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-Received-Bytes: 11042
 by: olcott - Wed, 17 Aug 2022 16:55 UTC

On 8/17/2022 11:25 AM, Dennis Bush wrote:
> On Wednesday, August 17, 2022 at 12:19:51 PM UTC-4, olcott wrote:
>> On 8/17/2022 11:06 AM, Dennis Bush wrote:
>>> On Wednesday, August 17, 2022 at 11:55:36 AM UTC-4, olcott wrote:
>>>> On 8/17/2022 10:35 AM, Dennis Bush wrote:
>>>>> On Wednesday, August 17, 2022 at 11:24:34 AM UTC-4, olcott wrote:
>>>>>> On 8/17/2022 9:51 AM, Dennis Bush wrote:
>>>>>>> On Wednesday, August 17, 2022 at 10:23:17 AM UTC-4, olcott wrote:
>>>>>>>> On 8/17/2022 6:40 AM, Dennis Bush wrote:
>>>>>>>>> On Wednesday, August 17, 2022 at 12:28:52 AM UTC-4, olcott wrote:
>>>>>>>>>> On 8/16/2022 11:02 PM, Dennis Bush wrote:
>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:57:51 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 8/16/2022 10:53 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:39:32 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 8/16/2022 10:23 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:18:46 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 8/16/2022 9:52 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:47:57 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>> On 8/16/2022 9:34 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:12:55 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 8/16/2022 8:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 8/16/22 9:20 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 8:10 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 8/16/22 10:27 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:07 AM, Skep Dick wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, 16 August 2022 at 15:55:30 UTC+2, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete x86 emulation of the input to H(P,P) by H
>>>>>>>>>>>>>>>>>>>>>>>>>> WOULD
>>>>>>>>>>>>>>>>>>>>>>>>>> never stop running.
>>>>>>>>>>>>>>>>>>>>>>>>> Sounds like you are stuck in a loop.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Maybe your Decider/Maker should terminate you.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> I have been trying to get an honest person to acknowledge the
>>>>>>>>>>>>>>>>>>>>>>>> correct software engineering of my system so that we can move on to
>>>>>>>>>>>>>>>>>>>>>>>> the next point for a year now. (bot many honest people here, mostly
>>>>>>>>>>>>>>>>>>>>>>>> trolls).
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The problem is that what you say ISN'T CORRECT software engineering.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You use the wrong definition of things and incorrect assumptions
>>>>>>>>>>>>>>>>>>>>>>> about thing, so it just isn't true.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) does correctly predict that its correct and complete x86
>>>>>>>>>>>>>>>>>>>>>>>> emulation of its input would never stop running, thus does correctly
>>>>>>>>>>>>>>>>>>>>>>>> reject this input as non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Nope. And in fact, you even acknoldge it doesn't but just don't see it.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> So you are saying that the correct and complete x86 emulation by
>>>>>>>>>>>>>>>>>>>>>> H(P,P) of its input WOULD STOP RUNNING?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> No, I am saying that you H doesn't do a correct and complete emulation
>>>>>>>>>>>>>>>>>>>>> of its input, and thus to say it did is just a LIE.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I said that H correctly predicts what the behavior of its correct and
>>>>>>>>>>>>>>>>>>>> complete x86 emulation of H(P,P) would be
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The fixed source code of H (and everything it calls) that aborts is Ha. Ha *always* aborts Pa, so "the correct and complete simulation of Ha(Pa,Pa)" does not exist, just like the shoes that Napoleon wore on Mars do not exist.
>>>>>>>>>>>>>>>>>> So you are another brain dead moron the believes it is utterly
>>>>>>>>>>>>>>>>>> impossible for H to correctly predict that its correct and complete x86
>>>>>>>>>>>>>>>>>> emulation of its input would never stop running unless H actually
>>>>>>>>>>>>>>>>>> performed a correct and complete emulation of its input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The correct and complete emulation of Ha(Pa,Pa) doesn't exist,
>>>>>>>>>>>>>>>> Neither does the correct and complete emulation of Infinite_Loop()
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Yes it does. If you simulate Infinite_Loop(), it won't halt. But if you run Ha(Pa,Pa), it won't do a correct and complete simulation because it aborts.
>>>>>>>>>>>>>> When you run H0((u32)Infinite_Loop)
>>>>>>>>>>>>>> "it won't do a correct and complete simulation because it aborts"
>>>>>>>>>>>>>> How long are you going to keep the head game up?
>>>>>>>>>>>>>
>>>>>>>>>>>>> That you don't understand what I'm saying doesn't make it a head game.
>>>>>>>>>>>>>
>>>>>>>>>>>> You reject Ha(Pa,Pa) on this basis
>>>>>>>>>>>> run Ha(Pa,Pa), it won't do a correct and complete simulation because it
>>>>>>>>>>>> aborts.
>>>>>>>>>>>> Yet accept P0(Infinite_Loop), on the same basis
>>>>>>>>>>>> it won't do a correct and complete simulation because it aborts.
>>>>>>>>>>>> ∴ You are playing head games.
>>>>>>>>>>>
>>>>>>>>>>> What does P0 do? Does it abort? If so, then yes P0(Infinite_Loop) doesn't do a correct and complete simulation because it aborts, so it's invalid to predict what the correct and complete simulation of P0(Infinite_Loop) would do.
>>>>>>>>>>>
>>>>>>>>>>> On the other hand, UTM(Infinite_Loop) does do a correct and complete simulation, so it *is* valid to predict what it will do.
>>>>>>>>>>>
>>>>>>>>>> In other words you are not bright enough to see that it is very easy for
>>>>>>>>>> H0 to recognize an infinite loop would never halt in a finite number of
>>>>>>>>>> steps of simulation?
>>>>>>>>>
>>>>>>>>> I'm saying that H0 can see that the correct and complete simulation performed by UTM(Infinite_Loop) does not halt. It does not and cannot see that the correct and complete simulation performed by H0(Infinite_Loop) (i.e. your basis for correctness) does not halt because H0 does not perform a correct and complete simulation.
>>>>>>>>>
>>>>>>>> This is what I mean by H evaluating what its correct and complete
>>>>>>>> simulation of its input would be:
>>>>>>>>
>>>>>>>> void P(ptr x)
>>>>>>>> {
>>>>>>>> int Halt_Status = Simulate(x, x);
>>>>>>>> if (Halt_Status)
>>>>>>>> HERE: goto HERE;
>>>>>>>> return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> Although H itself does not perform a correct and complete simulation of
>>>>>>>> non-halting inputs H does correctly predict that such a simulation would
>>>>>>>> never halt.
>>>>>>>
>>>>>>> You changed the input from Pa to Pn.
>>>>>>>
>>>>>>> So you're again saying that Ha(Pa,Pa) reports the halt status of the non-input Pn(Pn) instead of Pa(Pa) as it is required to:
>>>>>>>
>>>>>> H0(Infinite_Loop)
>>>>>> reports on Simulate(Infinite_Loop)
>>>>>>
>>>>>> H(Infinite_Recursion, 0x777)
>>>>>> reports on Simulate((Infinite_Recursion, 0x777)
>>>>>>
>>>>>> In every case a simulating halt decider reports on what the behavior of
>>>>>> its simulated input would be if this SHD was swapped for a simulator.
>>>>>
>>>>> And in the case of Ha(Pa,Pa) you change the input in doing so which is not allowed. Remember, what is being decided on is the FIXED source code of Pa and everything it calls, which includes the FIXED source code of Ha and everything it calls.
>>>> THIS JUST SEEMS OVER YOUR HEAD.
>>>> H correctly determines that its input would never halt by correctly
>>>> predicting that its input would never halt if H never aborted its
>>>> simulation of this input.
>>>
>>> Which is not what it is required to do if it claims to be a halt decider:
>>>
>>> For *any* algorithm X and input Y:
>>> H(X,Y)==1 if and only if X(Y) halts, and
>>> H(X,Y)==0 if and only if X(Y) does not halt
>>>
>> This is based on the false assumption that the actual behavior of the
>> actual input is the same behavior as X(Y).
>
> FALSE, because it is the behavior of the direct execution that is being asked about.


Click here to read the complete article
Re: Here is what a computer scientist that has been published in CACM said about my work [stupid]

<9ee5c99d-f30e-44d5-bdd9-e7213cfd8b16n@googlegroups.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
X-Received: by 2002:a05:620a:3c1:b0:6b8:e6e1:2950 with SMTP id r1-20020a05620a03c100b006b8e6e12950mr19346632qkm.651.1660755453091;
Wed, 17 Aug 2022 09:57:33 -0700 (PDT)
X-Received: by 2002:a25:7704:0:b0:692:6184:a56b with SMTP id
s4-20020a257704000000b006926184a56bmr334542ybc.16.1660755452911; Wed, 17 Aug
2022 09:57:32 -0700 (PDT)
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Wed, 17 Aug 2022 09:57:32 -0700 (PDT)
In-Reply-To: <0uWcnYwdfYD2gGD_nZ2dnZfqlJ_NnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=98.110.86.97; posting-account=ejFcQgoAAACAt5i0VbkATkR2ACWdgADD
NNTP-Posting-Host: 98.110.86.97
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<827c17dc-b5c5-4023-b73c-f77925c56c1an@googlegroups.com> <u8udnaC_csJhwGH_nZ2dnZfqlJxh4p2d@giganews.com>
<cf36a0c8-68d3-4eae-bcc2-39e36c5b1403n@googlegroups.com> <sySdnc8OUfRL_2H_nZ2dnZfqlJ9g4p2d@giganews.com>
<afafbc24-9373-4686-ac19-909a06ffaf79n@googlegroups.com> <c3Sdnf2c2IG_-mH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<2b06c9cb-4cb3-4866-a4ad-a5e9f10a6270n@googlegroups.com> <h_qdnUg9Jqn282H_nZ2dnZfqlJzNnZ2d@giganews.com>
<92857281-cb53-4ddc-908a-50d2937c403en@googlegroups.com> <kyCdnWCxIsAqZGH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<772d0a3b-f170-40c0-8abb-6569ae6cc5d5n@googlegroups.com> <xvydnfdGtIaElWD_nZ2dnZfqlJzNnZ2d@giganews.com>
<0a36df55-771f-4f26-a073-4dc34ac69942n@googlegroups.com> <xZGdnWjVQ-X8kmD_nZ2dnZfqlJzNnZ2d@giganews.com>
<43abc3f8-279b-4eca-ac54-dbcf7b276db9n@googlegroups.com> <iMecnScwOYKViGD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<68e43e9f-8ac6-45c8-ae2d-54cf74c76787n@googlegroups.com> <0uWcnYwdfYD2gGD_nZ2dnZfqlJ_NnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <9ee5c99d-f30e-44d5-bdd9-e7213cfd8b16n@googlegroups.com>
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [stupid]
From: dbush.mo...@gmail.com (Dennis Bush)
Injection-Date: Wed, 17 Aug 2022 16:57:33 +0000
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
X-Received-Bytes: 12081
 by: Dennis Bush - Wed, 17 Aug 2022 16:57 UTC

On Wednesday, August 17, 2022 at 12:55:38 PM UTC-4, olcott wrote:
> On 8/17/2022 11:25 AM, Dennis Bush wrote:
> > On Wednesday, August 17, 2022 at 12:19:51 PM UTC-4, olcott wrote:
> >> On 8/17/2022 11:06 AM, Dennis Bush wrote:
> >>> On Wednesday, August 17, 2022 at 11:55:36 AM UTC-4, olcott wrote:
> >>>> On 8/17/2022 10:35 AM, Dennis Bush wrote:
> >>>>> On Wednesday, August 17, 2022 at 11:24:34 AM UTC-4, olcott wrote:
> >>>>>> On 8/17/2022 9:51 AM, Dennis Bush wrote:
> >>>>>>> On Wednesday, August 17, 2022 at 10:23:17 AM UTC-4, olcott wrote:
> >>>>>>>> On 8/17/2022 6:40 AM, Dennis Bush wrote:
> >>>>>>>>> On Wednesday, August 17, 2022 at 12:28:52 AM UTC-4, olcott wrote:
> >>>>>>>>>> On 8/16/2022 11:02 PM, Dennis Bush wrote:
> >>>>>>>>>>> On Tuesday, August 16, 2022 at 11:57:51 PM UTC-4, olcott wrote:
> >>>>>>>>>>>> On 8/16/2022 10:53 PM, Dennis Bush wrote:
> >>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:39:32 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>> On 8/16/2022 10:23 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:18:46 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>> On 8/16/2022 9:52 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:47:57 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>> On 8/16/2022 9:34 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:12:55 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 8/16/2022 8:55 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>> On 8/16/22 9:20 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 8:10 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On 8/16/22 10:27 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:07 AM, Skep Dick wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, 16 August 2022 at 15:55:30 UTC+2, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete x86 emulation of the input to H(P,P) by H
> >>>>>>>>>>>>>>>>>>>>>>>>>> WOULD
> >>>>>>>>>>>>>>>>>>>>>>>>>> never stop running.
> >>>>>>>>>>>>>>>>>>>>>>>>> Sounds like you are stuck in a loop.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> Maybe your Decider/Maker should terminate you.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> I have been trying to get an honest person to acknowledge the
> >>>>>>>>>>>>>>>>>>>>>>>> correct software engineering of my system so that we can move on to
> >>>>>>>>>>>>>>>>>>>>>>>> the next point for a year now. (bot many honest people here, mostly
> >>>>>>>>>>>>>>>>>>>>>>>> trolls).
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> The problem is that what you say ISN'T CORRECT software engineering.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> You use the wrong definition of things and incorrect assumptions
> >>>>>>>>>>>>>>>>>>>>>>> about thing, so it just isn't true.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> H(P,P) does correctly predict that its correct and complete x86
> >>>>>>>>>>>>>>>>>>>>>>>> emulation of its input would never stop running, thus does correctly
> >>>>>>>>>>>>>>>>>>>>>>>> reject this input as non-halting.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> Nope. And in fact, you even acknoldge it doesn't but just don't see it.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> So you are saying that the correct and complete x86 emulation by
> >>>>>>>>>>>>>>>>>>>>>> H(P,P) of its input WOULD STOP RUNNING?
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> No, I am saying that you H doesn't do a correct and complete emulation
> >>>>>>>>>>>>>>>>>>>>> of its input, and thus to say it did is just a LIE.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> I said that H correctly predicts what the behavior of its correct and
> >>>>>>>>>>>>>>>>>>>> complete x86 emulation of H(P,P) would be
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> The fixed source code of H (and everything it calls) that aborts is Ha. Ha *always* aborts Pa, so "the correct and complete simulation of Ha(Pa,Pa)" does not exist, just like the shoes that Napoleon wore on Mars do not exist.
> >>>>>>>>>>>>>>>>>> So you are another brain dead moron the believes it is utterly
> >>>>>>>>>>>>>>>>>> impossible for H to correctly predict that its correct and complete x86
> >>>>>>>>>>>>>>>>>> emulation of its input would never stop running unless H actually
> >>>>>>>>>>>>>>>>>> performed a correct and complete emulation of its input.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> The correct and complete emulation of Ha(Pa,Pa) doesn't exist,
> >>>>>>>>>>>>>>>> Neither does the correct and complete emulation of Infinite_Loop()
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Yes it does. If you simulate Infinite_Loop(), it won't halt. But if you run Ha(Pa,Pa), it won't do a correct and complete simulation because it aborts.
> >>>>>>>>>>>>>> When you run H0((u32)Infinite_Loop)
> >>>>>>>>>>>>>> "it won't do a correct and complete simulation because it aborts"
> >>>>>>>>>>>>>> How long are you going to keep the head game up?
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> That you don't understand what I'm saying doesn't make it a head game.
> >>>>>>>>>>>>>
> >>>>>>>>>>>> You reject Ha(Pa,Pa) on this basis
> >>>>>>>>>>>> run Ha(Pa,Pa), it won't do a correct and complete simulation because it
> >>>>>>>>>>>> aborts.
> >>>>>>>>>>>> Yet accept P0(Infinite_Loop), on the same basis
> >>>>>>>>>>>> it won't do a correct and complete simulation because it aborts.
> >>>>>>>>>>>> ∴ You are playing head games.
> >>>>>>>>>>>
> >>>>>>>>>>> What does P0 do? Does it abort? If so, then yes P0(Infinite_Loop) doesn't do a correct and complete simulation because it aborts, so it's invalid to predict what the correct and complete simulation of P0(Infinite_Loop) would do.
> >>>>>>>>>>>
> >>>>>>>>>>> On the other hand, UTM(Infinite_Loop) does do a correct and complete simulation, so it *is* valid to predict what it will do.
> >>>>>>>>>>>
> >>>>>>>>>> In other words you are not bright enough to see that it is very easy for
> >>>>>>>>>> H0 to recognize an infinite loop would never halt in a finite number of
> >>>>>>>>>> steps of simulation?
> >>>>>>>>>
> >>>>>>>>> I'm saying that H0 can see that the correct and complete simulation performed by UTM(Infinite_Loop) does not halt. It does not and cannot see that the correct and complete simulation performed by H0(Infinite_Loop) (i.e. your basis for correctness) does not halt because H0 does not perform a correct and complete simulation.
> >>>>>>>>>
> >>>>>>>> This is what I mean by H evaluating what its correct and complete
> >>>>>>>> simulation of its input would be:
> >>>>>>>>
> >>>>>>>> void P(ptr x)
> >>>>>>>> {
> >>>>>>>> int Halt_Status = Simulate(x, x);
> >>>>>>>> if (Halt_Status)
> >>>>>>>> HERE: goto HERE;
> >>>>>>>> return;
> >>>>>>>> }
> >>>>>>>>
> >>>>>>>> Although H itself does not perform a correct and complete simulation of
> >>>>>>>> non-halting inputs H does correctly predict that such a simulation would
> >>>>>>>> never halt.
> >>>>>>>
> >>>>>>> You changed the input from Pa to Pn.
> >>>>>>>
> >>>>>>> So you're again saying that Ha(Pa,Pa) reports the halt status of the non-input Pn(Pn) instead of Pa(Pa) as it is required to:
> >>>>>>>
> >>>>>> H0(Infinite_Loop)
> >>>>>> reports on Simulate(Infinite_Loop)
> >>>>>>
> >>>>>> H(Infinite_Recursion, 0x777)
> >>>>>> reports on Simulate((Infinite_Recursion, 0x777)
> >>>>>>
> >>>>>> In every case a simulating halt decider reports on what the behavior of
> >>>>>> its simulated input would be if this SHD was swapped for a simulator.
> >>>>>
> >>>>> And in the case of Ha(Pa,Pa) you change the input in doing so which is not allowed. Remember, what is being decided on is the FIXED source code of Pa and everything it calls, which includes the FIXED source code of Ha and everything it calls.
> >>>> THIS JUST SEEMS OVER YOUR HEAD.
> >>>> H correctly determines that its input would never halt by correctly
> >>>> predicting that its input would never halt if H never aborted its
> >>>> simulation of this input.
> >>>
> >>> Which is not what it is required to do if it claims to be a halt decider:
> >>>
> >>> For *any* algorithm X and input Y:
> >>> H(X,Y)==1 if and only if X(Y) halts, and
> >>> H(X,Y)==0 if and only if X(Y) does not halt
> >>>
> >> This is based on the false assumption that the actual behavior of the
> >> actual input is the same behavior as X(Y).
> >
> > FALSE, because it is the behavior of the direct execution that is being asked about.
> So you disagree that every decider must base its decision on a semantic
> or syntactic property of its input?
>
> In other words you are asserting that a decider must base its decision
> on a semantic or syntactic property of a non-input?


Click here to read the complete article
Re: Here is what a computer scientist that has been published in CACM said about my work [stupid]

<IMOdnXoLpPFLvWD_nZ2dnZfqlJzNnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!rocksolid2!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border-2.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-1.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 17 Aug 2022 17:09:42 +0000
Date: Wed, 17 Aug 2022 12:09:59 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [stupid]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<cf36a0c8-68d3-4eae-bcc2-39e36c5b1403n@googlegroups.com>
<sySdnc8OUfRL_2H_nZ2dnZfqlJ9g4p2d@giganews.com>
<afafbc24-9373-4686-ac19-909a06ffaf79n@googlegroups.com>
<c3Sdnf2c2IG_-mH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<2b06c9cb-4cb3-4866-a4ad-a5e9f10a6270n@googlegroups.com>
<h_qdnUg9Jqn282H_nZ2dnZfqlJzNnZ2d@giganews.com>
<92857281-cb53-4ddc-908a-50d2937c403en@googlegroups.com>
<kyCdnWCxIsAqZGH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<772d0a3b-f170-40c0-8abb-6569ae6cc5d5n@googlegroups.com>
<xvydnfdGtIaElWD_nZ2dnZfqlJzNnZ2d@giganews.com>
<0a36df55-771f-4f26-a073-4dc34ac69942n@googlegroups.com>
<xZGdnWjVQ-X8kmD_nZ2dnZfqlJzNnZ2d@giganews.com>
<43abc3f8-279b-4eca-ac54-dbcf7b276db9n@googlegroups.com>
<iMecnScwOYKViGD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<68e43e9f-8ac6-45c8-ae2d-54cf74c76787n@googlegroups.com>
<0uWcnYwdfYD2gGD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<9ee5c99d-f30e-44d5-bdd9-e7213cfd8b16n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <9ee5c99d-f30e-44d5-bdd9-e7213cfd8b16n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <IMOdnXoLpPFLvWD_nZ2dnZfqlJzNnZ2d@giganews.com>
Lines: 188
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-oBz+7xUvU24xhzlMTStu0qO1oATqJ/pjG5R2Ny8W9pwhy53jc221DYBv71TErnldyVrlYvKWXt9HKfl!xVSMs3wUy+zVCEGAnkLe2T2QshbrqXSuDNsLf7n0T8/7EIhXJ4C1MWb2QBxnhmshrVGJ1zZIPuo=
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
 by: olcott - Wed, 17 Aug 2022 17:09 UTC

On 8/17/2022 11:57 AM, Dennis Bush wrote:
> On Wednesday, August 17, 2022 at 12:55:38 PM UTC-4, olcott wrote:
>> On 8/17/2022 11:25 AM, Dennis Bush wrote:
>>> On Wednesday, August 17, 2022 at 12:19:51 PM UTC-4, olcott wrote:
>>>> On 8/17/2022 11:06 AM, Dennis Bush wrote:
>>>>> On Wednesday, August 17, 2022 at 11:55:36 AM UTC-4, olcott wrote:
>>>>>> On 8/17/2022 10:35 AM, Dennis Bush wrote:
>>>>>>> On Wednesday, August 17, 2022 at 11:24:34 AM UTC-4, olcott wrote:
>>>>>>>> On 8/17/2022 9:51 AM, Dennis Bush wrote:
>>>>>>>>> On Wednesday, August 17, 2022 at 10:23:17 AM UTC-4, olcott wrote:
>>>>>>>>>> On 8/17/2022 6:40 AM, Dennis Bush wrote:
>>>>>>>>>>> On Wednesday, August 17, 2022 at 12:28:52 AM UTC-4, olcott wrote:
>>>>>>>>>>>> On 8/16/2022 11:02 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:57:51 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 8/16/2022 10:53 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:39:32 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 8/16/2022 10:23 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:18:46 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>> On 8/16/2022 9:52 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:47:57 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:34 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:12:55 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 8:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 8/16/22 9:20 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 8:10 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/22 10:27 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:07 AM, Skep Dick wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, 16 August 2022 at 15:55:30 UTC+2, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete x86 emulation of the input to H(P,P) by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> WOULD
>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stop running.
>>>>>>>>>>>>>>>>>>>>>>>>>>> Sounds like you are stuck in a loop.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Maybe your Decider/Maker should terminate you.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> I have been trying to get an honest person to acknowledge the
>>>>>>>>>>>>>>>>>>>>>>>>>> correct software engineering of my system so that we can move on to
>>>>>>>>>>>>>>>>>>>>>>>>>> the next point for a year now. (bot many honest people here, mostly
>>>>>>>>>>>>>>>>>>>>>>>>>> trolls).
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The problem is that what you say ISN'T CORRECT software engineering.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You use the wrong definition of things and incorrect assumptions
>>>>>>>>>>>>>>>>>>>>>>>>> about thing, so it just isn't true.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) does correctly predict that its correct and complete x86
>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of its input would never stop running, thus does correctly
>>>>>>>>>>>>>>>>>>>>>>>>>> reject this input as non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Nope. And in fact, you even acknoldge it doesn't but just don't see it.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So you are saying that the correct and complete x86 emulation by
>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) of its input WOULD STOP RUNNING?
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> No, I am saying that you H doesn't do a correct and complete emulation
>>>>>>>>>>>>>>>>>>>>>>> of its input, and thus to say it did is just a LIE.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> I said that H correctly predicts what the behavior of its correct and
>>>>>>>>>>>>>>>>>>>>>> complete x86 emulation of H(P,P) would be
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The fixed source code of H (and everything it calls) that aborts is Ha. Ha *always* aborts Pa, so "the correct and complete simulation of Ha(Pa,Pa)" does not exist, just like the shoes that Napoleon wore on Mars do not exist.
>>>>>>>>>>>>>>>>>>>> So you are another brain dead moron the believes it is utterly
>>>>>>>>>>>>>>>>>>>> impossible for H to correctly predict that its correct and complete x86
>>>>>>>>>>>>>>>>>>>> emulation of its input would never stop running unless H actually
>>>>>>>>>>>>>>>>>>>> performed a correct and complete emulation of its input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The correct and complete emulation of Ha(Pa,Pa) doesn't exist,
>>>>>>>>>>>>>>>>>> Neither does the correct and complete emulation of Infinite_Loop()
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Yes it does. If you simulate Infinite_Loop(), it won't halt. But if you run Ha(Pa,Pa), it won't do a correct and complete simulation because it aborts.
>>>>>>>>>>>>>>>> When you run H0((u32)Infinite_Loop)
>>>>>>>>>>>>>>>> "it won't do a correct and complete simulation because it aborts"
>>>>>>>>>>>>>>>> How long are you going to keep the head game up?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That you don't understand what I'm saying doesn't make it a head game.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You reject Ha(Pa,Pa) on this basis
>>>>>>>>>>>>>> run Ha(Pa,Pa), it won't do a correct and complete simulation because it
>>>>>>>>>>>>>> aborts.
>>>>>>>>>>>>>> Yet accept P0(Infinite_Loop), on the same basis
>>>>>>>>>>>>>> it won't do a correct and complete simulation because it aborts.
>>>>>>>>>>>>>> ∴ You are playing head games.
>>>>>>>>>>>>>
>>>>>>>>>>>>> What does P0 do? Does it abort? If so, then yes P0(Infinite_Loop) doesn't do a correct and complete simulation because it aborts, so it's invalid to predict what the correct and complete simulation of P0(Infinite_Loop) would do.
>>>>>>>>>>>>>
>>>>>>>>>>>>> On the other hand, UTM(Infinite_Loop) does do a correct and complete simulation, so it *is* valid to predict what it will do.
>>>>>>>>>>>>>
>>>>>>>>>>>> In other words you are not bright enough to see that it is very easy for
>>>>>>>>>>>> H0 to recognize an infinite loop would never halt in a finite number of
>>>>>>>>>>>> steps of simulation?
>>>>>>>>>>>
>>>>>>>>>>> I'm saying that H0 can see that the correct and complete simulation performed by UTM(Infinite_Loop) does not halt. It does not and cannot see that the correct and complete simulation performed by H0(Infinite_Loop) (i.e. your basis for correctness) does not halt because H0 does not perform a correct and complete simulation.
>>>>>>>>>>>
>>>>>>>>>> This is what I mean by H evaluating what its correct and complete
>>>>>>>>>> simulation of its input would be:
>>>>>>>>>>
>>>>>>>>>> void P(ptr x)
>>>>>>>>>> {
>>>>>>>>>> int Halt_Status = Simulate(x, x);
>>>>>>>>>> if (Halt_Status)
>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>> return;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> Although H itself does not perform a correct and complete simulation of
>>>>>>>>>> non-halting inputs H does correctly predict that such a simulation would
>>>>>>>>>> never halt.
>>>>>>>>>
>>>>>>>>> You changed the input from Pa to Pn.
>>>>>>>>>
>>>>>>>>> So you're again saying that Ha(Pa,Pa) reports the halt status of the non-input Pn(Pn) instead of Pa(Pa) as it is required to:
>>>>>>>>>
>>>>>>>> H0(Infinite_Loop)
>>>>>>>> reports on Simulate(Infinite_Loop)
>>>>>>>>
>>>>>>>> H(Infinite_Recursion, 0x777)
>>>>>>>> reports on Simulate((Infinite_Recursion, 0x777)
>>>>>>>>
>>>>>>>> In every case a simulating halt decider reports on what the behavior of
>>>>>>>> its simulated input would be if this SHD was swapped for a simulator.
>>>>>>>
>>>>>>> And in the case of Ha(Pa,Pa) you change the input in doing so which is not allowed. Remember, what is being decided on is the FIXED source code of Pa and everything it calls, which includes the FIXED source code of Ha and everything it calls.
>>>>>> THIS JUST SEEMS OVER YOUR HEAD.
>>>>>> H correctly determines that its input would never halt by correctly
>>>>>> predicting that its input would never halt if H never aborted its
>>>>>> simulation of this input.
>>>>>
>>>>> Which is not what it is required to do if it claims to be a halt decider:
>>>>>
>>>>> For *any* algorithm X and input Y:
>>>>> H(X,Y)==1 if and only if X(Y) halts, and
>>>>> H(X,Y)==0 if and only if X(Y) does not halt
>>>>>
>>>> This is based on the false assumption that the actual behavior of the
>>>> actual input is the same behavior as X(Y).
>>>
>>> FALSE, because it is the behavior of the direct execution that is being asked about.
>> So you disagree that every decider must base its decision on a semantic
>> or syntactic property of its input?
>>
>> In other words you are asserting that a decider must base its decision
>> on a semantic or syntactic property of a non-input?
>
> You're the one asserting that, as you think that Ha(Pa,Pa) should be reporting the halt status of Pn(Pn):
>


Click here to read the complete article
Re: Here is what a computer scientist that has been published in CACM said about my work [stupid]

<20220817181602.00000ee2@reddwarf.jmc.corp>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx08.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc.corp (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Here is what a computer scientist that has been published in
CACM said about my work [stupid]
Message-ID: <20220817181602.00000ee2@reddwarf.jmc.corp>
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<sySdnc8OUfRL_2H_nZ2dnZfqlJ9g4p2d@giganews.com>
<afafbc24-9373-4686-ac19-909a06ffaf79n@googlegroups.com>
<c3Sdnf2c2IG_-mH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<2b06c9cb-4cb3-4866-a4ad-a5e9f10a6270n@googlegroups.com>
<h_qdnUg9Jqn282H_nZ2dnZfqlJzNnZ2d@giganews.com>
<92857281-cb53-4ddc-908a-50d2937c403en@googlegroups.com>
<kyCdnWCxIsAqZGH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<772d0a3b-f170-40c0-8abb-6569ae6cc5d5n@googlegroups.com>
<xvydnfdGtIaElWD_nZ2dnZfqlJzNnZ2d@giganews.com>
<0a36df55-771f-4f26-a073-4dc34ac69942n@googlegroups.com>
<xZGdnWjVQ-X8kmD_nZ2dnZfqlJzNnZ2d@giganews.com>
<43abc3f8-279b-4eca-ac54-dbcf7b276db9n@googlegroups.com>
<iMecnScwOYKViGD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<68e43e9f-8ac6-45c8-ae2d-54cf74c76787n@googlegroups.com>
<0uWcnYwdfYD2gGD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<9ee5c99d-f30e-44d5-bdd9-e7213cfd8b16n@googlegroups.com>
<IMOdnXoLpPFLvWD_nZ2dnZfqlJzNnZ2d@giganews.com>
Organization: Jupiter Mining Corporation
X-Newsreader: Claws Mail 4.1.0 (GTK 3.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 226
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Wed, 17 Aug 2022 17:16:02 UTC
Date: Wed, 17 Aug 2022 18:16:02 +0100
X-Received-Bytes: 13280
 by: Mr Flibble - Wed, 17 Aug 2022 17:16 UTC

On Wed, 17 Aug 2022 12:09:59 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/17/2022 11:57 AM, Dennis Bush wrote:
> > On Wednesday, August 17, 2022 at 12:55:38 PM UTC-4, olcott wrote:
> >> On 8/17/2022 11:25 AM, Dennis Bush wrote:
> >>> On Wednesday, August 17, 2022 at 12:19:51 PM UTC-4, olcott wrote:
> >>>
> >>>> On 8/17/2022 11:06 AM, Dennis Bush wrote:
> >>>>> On Wednesday, August 17, 2022 at 11:55:36 AM UTC-4, olcott
> >>>>> wrote:
> >>>>>> On 8/17/2022 10:35 AM, Dennis Bush wrote:
> >>>>>>> On Wednesday, August 17, 2022 at 11:24:34 AM UTC-4, olcott
> >>>>>>> wrote:
> >>>>>>>> On 8/17/2022 9:51 AM, Dennis Bush wrote:
> >>>>>>>>> On Wednesday, August 17, 2022 at 10:23:17 AM UTC-4, olcott
> >>>>>>>>> wrote:
> >>>>>>>>>> On 8/17/2022 6:40 AM, Dennis Bush wrote:
> >>>>>>>>>>> On Wednesday, August 17, 2022 at 12:28:52 AM UTC-4,
> >>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>> On 8/16/2022 11:02 PM, Dennis Bush wrote:
> >>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:57:51 PM UTC-4,
> >>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>> On 8/16/2022 10:53 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:39:32 PM UTC-4,
> >>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>> On 8/16/2022 10:23 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:18:46 PM UTC-4,
> >>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>> On 8/16/2022 9:52 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:47:57 PM UTC-4,
> >>>>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:34 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:12:55 PM
> >>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 8:55 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On 8/16/22 9:20 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 8:10 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/22 10:27 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:07 AM, Skep Dick wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, 16 August 2022 at 15:55:30
> >>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+2, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete x86 emulation
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> of the input to H(P,P) by H WOULD
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> never stop running.
> >>>>>>>>>>>>>>>>>>>>>>>>>>> Sounds like you are stuck in a loop.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> Maybe your Decider/Maker should terminate
> >>>>>>>>>>>>>>>>>>>>>>>>>>> you.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> I have been trying to get an honest person
> >>>>>>>>>>>>>>>>>>>>>>>>>> to acknowledge the correct software
> >>>>>>>>>>>>>>>>>>>>>>>>>> engineering of my system so that we can
> >>>>>>>>>>>>>>>>>>>>>>>>>> move on to the next point for a year now.
> >>>>>>>>>>>>>>>>>>>>>>>>>> (bot many honest people here, mostly
> >>>>>>>>>>>>>>>>>>>>>>>>>> trolls).
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> The problem is that what you say ISN'T
> >>>>>>>>>>>>>>>>>>>>>>>>> CORRECT software engineering.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> You use the wrong definition of things and
> >>>>>>>>>>>>>>>>>>>>>>>>> incorrect assumptions about thing, so it
> >>>>>>>>>>>>>>>>>>>>>>>>> just isn't true.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) does correctly predict that its
> >>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of its
> >>>>>>>>>>>>>>>>>>>>>>>>>> input would never stop running, thus does
> >>>>>>>>>>>>>>>>>>>>>>>>>> correctly reject this input as
> >>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> Nope. And in fact, you even acknoldge it
> >>>>>>>>>>>>>>>>>>>>>>>>> doesn't but just don't see it.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> So you are saying that the correct and
> >>>>>>>>>>>>>>>>>>>>>>>> complete x86 emulation by H(P,P) of its
> >>>>>>>>>>>>>>>>>>>>>>>> input WOULD STOP RUNNING?
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> No, I am saying that you H doesn't do a
> >>>>>>>>>>>>>>>>>>>>>>> correct and complete emulation of its input,
> >>>>>>>>>>>>>>>>>>>>>>> and thus to say it did is just a LIE.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> I said that H correctly predicts what the
> >>>>>>>>>>>>>>>>>>>>>> behavior of its correct and complete x86
> >>>>>>>>>>>>>>>>>>>>>> emulation of H(P,P) would be
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> The fixed source code of H (and everything it
> >>>>>>>>>>>>>>>>>>>>> calls) that aborts is Ha. Ha *always* aborts
> >>>>>>>>>>>>>>>>>>>>> Pa, so "the correct and complete simulation of
> >>>>>>>>>>>>>>>>>>>>> Ha(Pa,Pa)" does not exist, just like the shoes
> >>>>>>>>>>>>>>>>>>>>> that Napoleon wore on Mars do not exist.
> >>>>>>>>>>>>>>>>>>>> So you are another brain dead moron the believes
> >>>>>>>>>>>>>>>>>>>> it is utterly impossible for H to correctly
> >>>>>>>>>>>>>>>>>>>> predict that its correct and complete x86
> >>>>>>>>>>>>>>>>>>>> emulation of its input would never stop running
> >>>>>>>>>>>>>>>>>>>> unless H actually performed a correct and
> >>>>>>>>>>>>>>>>>>>> complete emulation of its input.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> The correct and complete emulation of Ha(Pa,Pa)
> >>>>>>>>>>>>>>>>>>> doesn't exist,
> >>>>>>>>>>>>>>>>>> Neither does the correct and complete emulation of
> >>>>>>>>>>>>>>>>>> Infinite_Loop()
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Yes it does. If you simulate Infinite_Loop(), it
> >>>>>>>>>>>>>>>>> won't halt. But if you run Ha(Pa,Pa), it won't do a
> >>>>>>>>>>>>>>>>> correct and complete simulation because it aborts.
> >>>>>>>>>>>>>>>> When you run H0((u32)Infinite_Loop)
> >>>>>>>>>>>>>>>> "it won't do a correct and complete simulation
> >>>>>>>>>>>>>>>> because it aborts" How long are you going to keep
> >>>>>>>>>>>>>>>> the head game up?
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> That you don't understand what I'm saying doesn't
> >>>>>>>>>>>>>>> make it a head game.
> >>>>>>>>>>>>>> You reject Ha(Pa,Pa) on this basis
> >>>>>>>>>>>>>> run Ha(Pa,Pa), it won't do a correct and complete
> >>>>>>>>>>>>>> simulation because it aborts.
> >>>>>>>>>>>>>> Yet accept P0(Infinite_Loop), on the same basis
> >>>>>>>>>>>>>> it won't do a correct and complete simulation because
> >>>>>>>>>>>>>> it aborts. ∴ You are playing head games.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> What does P0 do? Does it abort? If so, then yes
> >>>>>>>>>>>>> P0(Infinite_Loop) doesn't do a correct and complete
> >>>>>>>>>>>>> simulation because it aborts, so it's invalid to
> >>>>>>>>>>>>> predict what the correct and complete simulation of
> >>>>>>>>>>>>> P0(Infinite_Loop) would do.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> On the other hand, UTM(Infinite_Loop) does do a correct
> >>>>>>>>>>>>> and complete simulation, so it *is* valid to predict
> >>>>>>>>>>>>> what it will do.
> >>>>>>>>>>>> In other words you are not bright enough to see that it
> >>>>>>>>>>>> is very easy for H0 to recognize an infinite loop would
> >>>>>>>>>>>> never halt in a finite number of steps of simulation?
> >>>>>>>>>>>
> >>>>>>>>>>> I'm saying that H0 can see that the correct and complete
> >>>>>>>>>>> simulation performed by UTM(Infinite_Loop) does not halt.
> >>>>>>>>>>> It does not and cannot see that the correct and complete
> >>>>>>>>>>> simulation performed by H0(Infinite_Loop) (i.e. your
> >>>>>>>>>>> basis for correctness) does not halt because H0 does not
> >>>>>>>>>>> perform a correct and complete simulation.
> >>>>>>>>>> This is what I mean by H evaluating what its correct and
> >>>>>>>>>> complete simulation of its input would be:
> >>>>>>>>>>
> >>>>>>>>>> void P(ptr x)
> >>>>>>>>>> {
> >>>>>>>>>> int Halt_Status = Simulate(x, x);
> >>>>>>>>>> if (Halt_Status)
> >>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>> return;
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> Although H itself does not perform a correct and complete
> >>>>>>>>>> simulation of non-halting inputs H does correctly predict
> >>>>>>>>>> that such a simulation would never halt.
> >>>>>>>>>
> >>>>>>>>> You changed the input from Pa to Pn.
> >>>>>>>>>
> >>>>>>>>> So you're again saying that Ha(Pa,Pa) reports the halt
> >>>>>>>>> status of the non-input Pn(Pn) instead of Pa(Pa) as it is
> >>>>>>>>> required to:
> >>>>>>>> H0(Infinite_Loop)
> >>>>>>>> reports on Simulate(Infinite_Loop)
> >>>>>>>>
> >>>>>>>> H(Infinite_Recursion, 0x777)
> >>>>>>>> reports on Simulate((Infinite_Recursion, 0x777)
> >>>>>>>>
> >>>>>>>> In every case a simulating halt decider reports on what the
> >>>>>>>> behavior of its simulated input would be if this SHD was
> >>>>>>>> swapped for a simulator.
> >>>>>>>
> >>>>>>> And in the case of Ha(Pa,Pa) you change the input in doing so
> >>>>>>> which is not allowed. Remember, what is being decided on is
> >>>>>>> the FIXED source code of Pa and everything it calls, which
> >>>>>>> includes the FIXED source code of Ha and everything it calls.
> >>>>>>>
> >>>>>> THIS JUST SEEMS OVER YOUR HEAD.
> >>>>>> H correctly determines that its input would never halt by
> >>>>>> correctly predicting that its input would never halt if H
> >>>>>> never aborted its simulation of this input.
> >>>>>
> >>>>> Which is not what it is required to do if it claims to be a
> >>>>> halt decider:
> >>>>>
> >>>>> For *any* algorithm X and input Y:
> >>>>> H(X,Y)==1 if and only if X(Y) halts, and
> >>>>> H(X,Y)==0 if and only if X(Y) does not halt
> >>>>>
> >>>> This is based on the false assumption that the actual behavior
> >>>> of the actual input is the same behavior as X(Y).
> >>>
> >>> FALSE, because it is the behavior of the direct execution that is
> >>> being asked about.
> >> So you disagree that every decider must base its decision on a
> >> semantic or syntactic property of its input?
> >>
> >> In other words you are asserting that a decider must base its
> >> decision on a semantic or syntactic property of a non-input?
> >
> > You're the one asserting that, as you think that Ha(Pa,Pa) should
> > be reporting the halt status of Pn(Pn):
>
> H is reporting on the behavior that these machine language bytes
> specify:
> 558bec518b4508508b4d0851e8bffeffff83c4088945fc837dfc007402ebfe8be55dc3
>
> _P()
> [00000fc2](01) 55 push ebp
> [00000fc3](02) 8bec mov ebp,esp
> [00000fc5](01) 51 push ecx
> [00000fc6](03) 8b4508 mov eax,[ebp+08]
> [00000fc9](01) 50 push eax
> [00000fca](03) 8b4d08 mov ecx,[ebp+08]
> [00000fcd](01) 51 push ecx
> [00000fce](05) e8bffeffff call 00000e92
> [00000fd3](03) 83c408 add esp,+08
> [00000fd6](03) 8945fc mov [ebp-04],eax
> [00000fd9](04) 837dfc00 cmp dword [ebp-04],+00
> [00000fdd](02) 7402 jz 00000fe1
> [00000fdf](02) ebfe jmp 00000fdf
> [00000fe1](02) 8be5 mov esp,ebp
> [00000fe3](01) 5d pop ebp
> [00000fe4](01) c3 ret
> Size in bytes:(0035) [00000fe4]


Click here to read the complete article
Re: Here is what a computer scientist that has been published in CACM said about my work [stupid]

<buidnToEtpcwuGD_nZ2dnZfqlJzNnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!1.us.feeder.erje.net!feeder.erje.net!border-1.nntp.ord.giganews.com!border-2.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-1.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 17 Aug 2022 17:30:21 +0000
Date: Wed, 17 Aug 2022 12:30:38 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [stupid]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<cf36a0c8-68d3-4eae-bcc2-39e36c5b1403n@googlegroups.com>
<sySdnc8OUfRL_2H_nZ2dnZfqlJ9g4p2d@giganews.com>
<afafbc24-9373-4686-ac19-909a06ffaf79n@googlegroups.com>
<c3Sdnf2c2IG_-mH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<2b06c9cb-4cb3-4866-a4ad-a5e9f10a6270n@googlegroups.com>
<h_qdnUg9Jqn282H_nZ2dnZfqlJzNnZ2d@giganews.com>
<92857281-cb53-4ddc-908a-50d2937c403en@googlegroups.com>
<kyCdnWCxIsAqZGH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<772d0a3b-f170-40c0-8abb-6569ae6cc5d5n@googlegroups.com>
<xvydnfdGtIaElWD_nZ2dnZfqlJzNnZ2d@giganews.com>
<0a36df55-771f-4f26-a073-4dc34ac69942n@googlegroups.com>
<xZGdnWjVQ-X8kmD_nZ2dnZfqlJzNnZ2d@giganews.com>
<43abc3f8-279b-4eca-ac54-dbcf7b276db9n@googlegroups.com>
<iMecnScwOYKViGD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<68e43e9f-8ac6-45c8-ae2d-54cf74c76787n@googlegroups.com>
<0uWcnYwdfYD2gGD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<9ee5c99d-f30e-44d5-bdd9-e7213cfd8b16n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <9ee5c99d-f30e-44d5-bdd9-e7213cfd8b16n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <buidnToEtpcwuGD_nZ2dnZfqlJzNnZ2d@giganews.com>
Lines: 170
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-NqvxkJBKl9uCXXO5B+LvQ8x1Ad08KiR+QN4f2EnGk7YxA0aUUFs4MdDebscso1hcbeRAlUu6Vxr0ssW!h7YTvc6d8AXGWfesO5Tts6zXnsq+ka3t381yrdizy8e+aENbWh3QWUWq8M5cSowOcWYxcpk4wfI=
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
 by: olcott - Wed, 17 Aug 2022 17:30 UTC

On 8/17/2022 11:57 AM, Dennis Bush wrote:
> On Wednesday, August 17, 2022 at 12:55:38 PM UTC-4, olcott wrote:
>> On 8/17/2022 11:25 AM, Dennis Bush wrote:
>>> On Wednesday, August 17, 2022 at 12:19:51 PM UTC-4, olcott wrote:
>>>> On 8/17/2022 11:06 AM, Dennis Bush wrote:
>>>>> On Wednesday, August 17, 2022 at 11:55:36 AM UTC-4, olcott wrote:
>>>>>> On 8/17/2022 10:35 AM, Dennis Bush wrote:
>>>>>>> On Wednesday, August 17, 2022 at 11:24:34 AM UTC-4, olcott wrote:
>>>>>>>> On 8/17/2022 9:51 AM, Dennis Bush wrote:
>>>>>>>>> On Wednesday, August 17, 2022 at 10:23:17 AM UTC-4, olcott wrote:
>>>>>>>>>> On 8/17/2022 6:40 AM, Dennis Bush wrote:
>>>>>>>>>>> On Wednesday, August 17, 2022 at 12:28:52 AM UTC-4, olcott wrote:
>>>>>>>>>>>> On 8/16/2022 11:02 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:57:51 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 8/16/2022 10:53 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:39:32 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 8/16/2022 10:23 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:18:46 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>> On 8/16/2022 9:52 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:47:57 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:34 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:12:55 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 8:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 8/16/22 9:20 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 8:10 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/22 10:27 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:07 AM, Skep Dick wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, 16 August 2022 at 15:55:30 UTC+2, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete x86 emulation of the input to H(P,P) by H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> WOULD
>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stop running.
>>>>>>>>>>>>>>>>>>>>>>>>>>> Sounds like you are stuck in a loop.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Maybe your Decider/Maker should terminate you.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> I have been trying to get an honest person to acknowledge the
>>>>>>>>>>>>>>>>>>>>>>>>>> correct software engineering of my system so that we can move on to
>>>>>>>>>>>>>>>>>>>>>>>>>> the next point for a year now. (bot many honest people here, mostly
>>>>>>>>>>>>>>>>>>>>>>>>>> trolls).
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The problem is that what you say ISN'T CORRECT software engineering.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You use the wrong definition of things and incorrect assumptions
>>>>>>>>>>>>>>>>>>>>>>>>> about thing, so it just isn't true.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) does correctly predict that its correct and complete x86
>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of its input would never stop running, thus does correctly
>>>>>>>>>>>>>>>>>>>>>>>>>> reject this input as non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Nope. And in fact, you even acknoldge it doesn't but just don't see it.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So you are saying that the correct and complete x86 emulation by
>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) of its input WOULD STOP RUNNING?
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> No, I am saying that you H doesn't do a correct and complete emulation
>>>>>>>>>>>>>>>>>>>>>>> of its input, and thus to say it did is just a LIE.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> I said that H correctly predicts what the behavior of its correct and
>>>>>>>>>>>>>>>>>>>>>> complete x86 emulation of H(P,P) would be
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The fixed source code of H (and everything it calls) that aborts is Ha. Ha *always* aborts Pa, so "the correct and complete simulation of Ha(Pa,Pa)" does not exist, just like the shoes that Napoleon wore on Mars do not exist.
>>>>>>>>>>>>>>>>>>>> So you are another brain dead moron the believes it is utterly
>>>>>>>>>>>>>>>>>>>> impossible for H to correctly predict that its correct and complete x86
>>>>>>>>>>>>>>>>>>>> emulation of its input would never stop running unless H actually
>>>>>>>>>>>>>>>>>>>> performed a correct and complete emulation of its input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The correct and complete emulation of Ha(Pa,Pa) doesn't exist,
>>>>>>>>>>>>>>>>>> Neither does the correct and complete emulation of Infinite_Loop()
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Yes it does. If you simulate Infinite_Loop(), it won't halt. But if you run Ha(Pa,Pa), it won't do a correct and complete simulation because it aborts.
>>>>>>>>>>>>>>>> When you run H0((u32)Infinite_Loop)
>>>>>>>>>>>>>>>> "it won't do a correct and complete simulation because it aborts"
>>>>>>>>>>>>>>>> How long are you going to keep the head game up?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That you don't understand what I'm saying doesn't make it a head game.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You reject Ha(Pa,Pa) on this basis
>>>>>>>>>>>>>> run Ha(Pa,Pa), it won't do a correct and complete simulation because it
>>>>>>>>>>>>>> aborts.
>>>>>>>>>>>>>> Yet accept P0(Infinite_Loop), on the same basis
>>>>>>>>>>>>>> it won't do a correct and complete simulation because it aborts.
>>>>>>>>>>>>>> ∴ You are playing head games.
>>>>>>>>>>>>>
>>>>>>>>>>>>> What does P0 do? Does it abort? If so, then yes P0(Infinite_Loop) doesn't do a correct and complete simulation because it aborts, so it's invalid to predict what the correct and complete simulation of P0(Infinite_Loop) would do.
>>>>>>>>>>>>>
>>>>>>>>>>>>> On the other hand, UTM(Infinite_Loop) does do a correct and complete simulation, so it *is* valid to predict what it will do.
>>>>>>>>>>>>>
>>>>>>>>>>>> In other words you are not bright enough to see that it is very easy for
>>>>>>>>>>>> H0 to recognize an infinite loop would never halt in a finite number of
>>>>>>>>>>>> steps of simulation?
>>>>>>>>>>>
>>>>>>>>>>> I'm saying that H0 can see that the correct and complete simulation performed by UTM(Infinite_Loop) does not halt. It does not and cannot see that the correct and complete simulation performed by H0(Infinite_Loop) (i.e. your basis for correctness) does not halt because H0 does not perform a correct and complete simulation.
>>>>>>>>>>>
>>>>>>>>>> This is what I mean by H evaluating what its correct and complete
>>>>>>>>>> simulation of its input would be:
>>>>>>>>>>
>>>>>>>>>> void P(ptr x)
>>>>>>>>>> {
>>>>>>>>>> int Halt_Status = Simulate(x, x);
>>>>>>>>>> if (Halt_Status)
>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>> return;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> Although H itself does not perform a correct and complete simulation of
>>>>>>>>>> non-halting inputs H does correctly predict that such a simulation would
>>>>>>>>>> never halt.
>>>>>>>>>
>>>>>>>>> You changed the input from Pa to Pn.
>>>>>>>>>
>>>>>>>>> So you're again saying that Ha(Pa,Pa) reports the halt status of the non-input Pn(Pn) instead of Pa(Pa) as it is required to:
>>>>>>>>>
>>>>>>>> H0(Infinite_Loop)
>>>>>>>> reports on Simulate(Infinite_Loop)
>>>>>>>>
>>>>>>>> H(Infinite_Recursion, 0x777)
>>>>>>>> reports on Simulate((Infinite_Recursion, 0x777)
>>>>>>>>
>>>>>>>> In every case a simulating halt decider reports on what the behavior of
>>>>>>>> its simulated input would be if this SHD was swapped for a simulator.
>>>>>>>
>>>>>>> And in the case of Ha(Pa,Pa) you change the input in doing so which is not allowed. Remember, what is being decided on is the FIXED source code of Pa and everything it calls, which includes the FIXED source code of Ha and everything it calls.
>>>>>> THIS JUST SEEMS OVER YOUR HEAD.
>>>>>> H correctly determines that its input would never halt by correctly
>>>>>> predicting that its input would never halt if H never aborted its
>>>>>> simulation of this input.
>>>>>
>>>>> Which is not what it is required to do if it claims to be a halt decider:
>>>>>
>>>>> For *any* algorithm X and input Y:
>>>>> H(X,Y)==1 if and only if X(Y) halts, and
>>>>> H(X,Y)==0 if and only if X(Y) does not halt
>>>>>
>>>> This is based on the false assumption that the actual behavior of the
>>>> actual input is the same behavior as X(Y).
>>>
>>> FALSE, because it is the behavior of the direct execution that is being asked about.
>> So you disagree that every decider must base its decision on a semantic
>> or syntactic property of its input?
>>
>> In other words you are asserting that a decider must base its decision
>> on a semantic or syntactic property of a non-input?
>
> You're the one asserting that, as you think that Ha(Pa,Pa) should be reporting the halt status of Pn(Pn):
>
A simulating halt decider always reports on what the behavior of its
pure simulation of its input would be on the basis of recognizing an
infinite behavior pattern that correctly predicts what the behavior of
this pure simulation would be without the need to actually perform this
pure simulation.


Click here to read the complete article
Re: Here is what a computer scientist that has been published in CACM said about my work [stupid]

<01d31eaa-8c1b-403c-9823-fb19f32fb19en@googlegroups.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
X-Received: by 2002:a05:620a:290d:b0:6b5:cecc:1cab with SMTP id m13-20020a05620a290d00b006b5cecc1cabmr18543538qkp.465.1660757548096;
Wed, 17 Aug 2022 10:32:28 -0700 (PDT)
X-Received: by 2002:a05:6902:10ca:b0:671:3616:9147 with SMTP id
w10-20020a05690210ca00b0067136169147mr20126585ybu.105.1660757547770; Wed, 17
Aug 2022 10:32:27 -0700 (PDT)
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Wed, 17 Aug 2022 10:32:27 -0700 (PDT)
In-Reply-To: <IMOdnXoLpPFLvWD_nZ2dnZfqlJzNnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=98.110.86.97; posting-account=ejFcQgoAAACAt5i0VbkATkR2ACWdgADD
NNTP-Posting-Host: 98.110.86.97
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<cf36a0c8-68d3-4eae-bcc2-39e36c5b1403n@googlegroups.com> <sySdnc8OUfRL_2H_nZ2dnZfqlJ9g4p2d@giganews.com>
<afafbc24-9373-4686-ac19-909a06ffaf79n@googlegroups.com> <c3Sdnf2c2IG_-mH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<2b06c9cb-4cb3-4866-a4ad-a5e9f10a6270n@googlegroups.com> <h_qdnUg9Jqn282H_nZ2dnZfqlJzNnZ2d@giganews.com>
<92857281-cb53-4ddc-908a-50d2937c403en@googlegroups.com> <kyCdnWCxIsAqZGH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<772d0a3b-f170-40c0-8abb-6569ae6cc5d5n@googlegroups.com> <xvydnfdGtIaElWD_nZ2dnZfqlJzNnZ2d@giganews.com>
<0a36df55-771f-4f26-a073-4dc34ac69942n@googlegroups.com> <xZGdnWjVQ-X8kmD_nZ2dnZfqlJzNnZ2d@giganews.com>
<43abc3f8-279b-4eca-ac54-dbcf7b276db9n@googlegroups.com> <iMecnScwOYKViGD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<68e43e9f-8ac6-45c8-ae2d-54cf74c76787n@googlegroups.com> <0uWcnYwdfYD2gGD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<9ee5c99d-f30e-44d5-bdd9-e7213cfd8b16n@googlegroups.com> <IMOdnXoLpPFLvWD_nZ2dnZfqlJzNnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <01d31eaa-8c1b-403c-9823-fb19f32fb19en@googlegroups.com>
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [stupid]
From: dbush.mo...@gmail.com (Dennis Bush)
Injection-Date: Wed, 17 Aug 2022 17:32:28 +0000
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
X-Received-Bytes: 13421
 by: Dennis Bush - Wed, 17 Aug 2022 17:32 UTC

On Wednesday, August 17, 2022 at 1:10:05 PM UTC-4, olcott wrote:
> On 8/17/2022 11:57 AM, Dennis Bush wrote:
> > On Wednesday, August 17, 2022 at 12:55:38 PM UTC-4, olcott wrote:
> >> On 8/17/2022 11:25 AM, Dennis Bush wrote:
> >>> On Wednesday, August 17, 2022 at 12:19:51 PM UTC-4, olcott wrote:
> >>>> On 8/17/2022 11:06 AM, Dennis Bush wrote:
> >>>>> On Wednesday, August 17, 2022 at 11:55:36 AM UTC-4, olcott wrote:
> >>>>>> On 8/17/2022 10:35 AM, Dennis Bush wrote:
> >>>>>>> On Wednesday, August 17, 2022 at 11:24:34 AM UTC-4, olcott wrote:
> >>>>>>>> On 8/17/2022 9:51 AM, Dennis Bush wrote:
> >>>>>>>>> On Wednesday, August 17, 2022 at 10:23:17 AM UTC-4, olcott wrote:
> >>>>>>>>>> On 8/17/2022 6:40 AM, Dennis Bush wrote:
> >>>>>>>>>>> On Wednesday, August 17, 2022 at 12:28:52 AM UTC-4, olcott wrote:
> >>>>>>>>>>>> On 8/16/2022 11:02 PM, Dennis Bush wrote:
> >>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:57:51 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>> On 8/16/2022 10:53 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:39:32 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>> On 8/16/2022 10:23 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:18:46 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>> On 8/16/2022 9:52 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:47:57 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:34 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:12:55 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 8:55 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On 8/16/22 9:20 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 8:10 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/22 10:27 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:07 AM, Skep Dick wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, 16 August 2022 at 15:55:30 UTC+2, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete x86 emulation of the input to H(P,P) by H
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> WOULD
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> never stop running.
> >>>>>>>>>>>>>>>>>>>>>>>>>>> Sounds like you are stuck in a loop.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> Maybe your Decider/Maker should terminate you..
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> I have been trying to get an honest person to acknowledge the
> >>>>>>>>>>>>>>>>>>>>>>>>>> correct software engineering of my system so that we can move on to
> >>>>>>>>>>>>>>>>>>>>>>>>>> the next point for a year now. (bot many honest people here, mostly
> >>>>>>>>>>>>>>>>>>>>>>>>>> trolls).
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> The problem is that what you say ISN'T CORRECT software engineering.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> You use the wrong definition of things and incorrect assumptions
> >>>>>>>>>>>>>>>>>>>>>>>>> about thing, so it just isn't true.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) does correctly predict that its correct and complete x86
> >>>>>>>>>>>>>>>>>>>>>>>>>> emulation of its input would never stop running, thus does correctly
> >>>>>>>>>>>>>>>>>>>>>>>>>> reject this input as non-halting.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> Nope. And in fact, you even acknoldge it doesn't but just don't see it.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> So you are saying that the correct and complete x86 emulation by
> >>>>>>>>>>>>>>>>>>>>>>>> H(P,P) of its input WOULD STOP RUNNING?
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> No, I am saying that you H doesn't do a correct and complete emulation
> >>>>>>>>>>>>>>>>>>>>>>> of its input, and thus to say it did is just a LIE.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> I said that H correctly predicts what the behavior of its correct and
> >>>>>>>>>>>>>>>>>>>>>> complete x86 emulation of H(P,P) would be
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> The fixed source code of H (and everything it calls) that aborts is Ha. Ha *always* aborts Pa, so "the correct and complete simulation of Ha(Pa,Pa)" does not exist, just like the shoes that Napoleon wore on Mars do not exist.
> >>>>>>>>>>>>>>>>>>>> So you are another brain dead moron the believes it is utterly
> >>>>>>>>>>>>>>>>>>>> impossible for H to correctly predict that its correct and complete x86
> >>>>>>>>>>>>>>>>>>>> emulation of its input would never stop running unless H actually
> >>>>>>>>>>>>>>>>>>>> performed a correct and complete emulation of its input.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> The correct and complete emulation of Ha(Pa,Pa) doesn't exist,
> >>>>>>>>>>>>>>>>>> Neither does the correct and complete emulation of Infinite_Loop()
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Yes it does. If you simulate Infinite_Loop(), it won't halt. But if you run Ha(Pa,Pa), it won't do a correct and complete simulation because it aborts.
> >>>>>>>>>>>>>>>> When you run H0((u32)Infinite_Loop)
> >>>>>>>>>>>>>>>> "it won't do a correct and complete simulation because it aborts"
> >>>>>>>>>>>>>>>> How long are you going to keep the head game up?
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> That you don't understand what I'm saying doesn't make it a head game.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>> You reject Ha(Pa,Pa) on this basis
> >>>>>>>>>>>>>> run Ha(Pa,Pa), it won't do a correct and complete simulation because it
> >>>>>>>>>>>>>> aborts.
> >>>>>>>>>>>>>> Yet accept P0(Infinite_Loop), on the same basis
> >>>>>>>>>>>>>> it won't do a correct and complete simulation because it aborts.
> >>>>>>>>>>>>>> ∴ You are playing head games.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> What does P0 do? Does it abort? If so, then yes P0(Infinite_Loop) doesn't do a correct and complete simulation because it aborts, so it's invalid to predict what the correct and complete simulation of P0(Infinite_Loop) would do.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> On the other hand, UTM(Infinite_Loop) does do a correct and complete simulation, so it *is* valid to predict what it will do.
> >>>>>>>>>>>>>
> >>>>>>>>>>>> In other words you are not bright enough to see that it is very easy for
> >>>>>>>>>>>> H0 to recognize an infinite loop would never halt in a finite number of
> >>>>>>>>>>>> steps of simulation?
> >>>>>>>>>>>
> >>>>>>>>>>> I'm saying that H0 can see that the correct and complete simulation performed by UTM(Infinite_Loop) does not halt. It does not and cannot see that the correct and complete simulation performed by H0(Infinite_Loop) (i.e. your basis for correctness) does not halt because H0 does not perform a correct and complete simulation.
> >>>>>>>>>>>
> >>>>>>>>>> This is what I mean by H evaluating what its correct and complete
> >>>>>>>>>> simulation of its input would be:
> >>>>>>>>>>
> >>>>>>>>>> void P(ptr x)
> >>>>>>>>>> {
> >>>>>>>>>> int Halt_Status = Simulate(x, x);
> >>>>>>>>>> if (Halt_Status)
> >>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>> return;
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> Although H itself does not perform a correct and complete simulation of
> >>>>>>>>>> non-halting inputs H does correctly predict that such a simulation would
> >>>>>>>>>> never halt.
> >>>>>>>>>
> >>>>>>>>> You changed the input from Pa to Pn.
> >>>>>>>>>
> >>>>>>>>> So you're again saying that Ha(Pa,Pa) reports the halt status of the non-input Pn(Pn) instead of Pa(Pa) as it is required to:
> >>>>>>>>>
> >>>>>>>> H0(Infinite_Loop)
> >>>>>>>> reports on Simulate(Infinite_Loop)
> >>>>>>>>
> >>>>>>>> H(Infinite_Recursion, 0x777)
> >>>>>>>> reports on Simulate((Infinite_Recursion, 0x777)
> >>>>>>>>
> >>>>>>>> In every case a simulating halt decider reports on what the behavior of
> >>>>>>>> its simulated input would be if this SHD was swapped for a simulator.
> >>>>>>>
> >>>>>>> And in the case of Ha(Pa,Pa) you change the input in doing so which is not allowed. Remember, what is being decided on is the FIXED source code of Pa and everything it calls, which includes the FIXED source code of Ha and everything it calls.
> >>>>>> THIS JUST SEEMS OVER YOUR HEAD.
> >>>>>> H correctly determines that its input would never halt by correctly
> >>>>>> predicting that its input would never halt if H never aborted its
> >>>>>> simulation of this input.
> >>>>>
> >>>>> Which is not what it is required to do if it claims to be a halt decider:
> >>>>>
> >>>>> For *any* algorithm X and input Y:
> >>>>> H(X,Y)==1 if and only if X(Y) halts, and
> >>>>> H(X,Y)==0 if and only if X(Y) does not halt
> >>>>>
> >>>> This is based on the false assumption that the actual behavior of the
> >>>> actual input is the same behavior as X(Y).
> >>>
> >>> FALSE, because it is the behavior of the direct execution that is being asked about.
> >> So you disagree that every decider must base its decision on a semantic
> >> or syntactic property of its input?
> >>
> >> In other words you are asserting that a decider must base its decision
> >> on a semantic or syntactic property of a non-input?
> >
> > You're the one asserting that, as you think that Ha(Pa,Pa) should be reporting the halt status of Pn(Pn):
> >
> H is reporting on the behavior that these machine language bytes
> specify:
> 558bec518b4508508b4d0851e8bffeffff83c4088945fc837dfc007402ebfe8be55dc3
>
> _P()
> [00000fc2](01) 55 push ebp
> [00000fc3](02) 8bec mov ebp,esp
> [00000fc5](01) 51 push ecx
> [00000fc6](03) 8b4508 mov eax,[ebp+08]
> [00000fc9](01) 50 push eax
> [00000fca](03) 8b4d08 mov ecx,[ebp+08]
> [00000fcd](01) 51 push ecx
> [00000fce](05) e8bffeffff call 00000e92
> [00000fd3](03) 83c408 add esp,+08
> [00000fd6](03) 8945fc mov [ebp-04],eax
> [00000fd9](04) 837dfc00 cmp dword [ebp-04],+00
> [00000fdd](02) 7402 jz 00000fe1
> [00000fdf](02) ebfe jmp 00000fdf
> [00000fe1](02) 8be5 mov esp,ebp
> [00000fe3](01) 5d pop ebp
> [00000fe4](01) c3 ret
> Size in bytes:(0035) [00000fe4]


Click here to read the complete article
Re: Here is what a computer scientist that has been published in CACM said about my work [stupid]

<faff2ed1-3eb1-4c44-b394-4e4b8cf96785n@googlegroups.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
X-Received: by 2002:a05:620a:4502:b0:6b4:6c2f:e7b7 with SMTP id t2-20020a05620a450200b006b46c2fe7b7mr19272139qkp.11.1660757684640;
Wed, 17 Aug 2022 10:34:44 -0700 (PDT)
X-Received: by 2002:a25:9f0e:0:b0:691:f74:9ed6 with SMTP id
n14-20020a259f0e000000b006910f749ed6mr2684036ybq.307.1660757684267; Wed, 17
Aug 2022 10:34:44 -0700 (PDT)
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Wed, 17 Aug 2022 10:34:44 -0700 (PDT)
In-Reply-To: <buidnToEtpcwuGD_nZ2dnZfqlJzNnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=98.110.86.97; posting-account=ejFcQgoAAACAt5i0VbkATkR2ACWdgADD
NNTP-Posting-Host: 98.110.86.97
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<cf36a0c8-68d3-4eae-bcc2-39e36c5b1403n@googlegroups.com> <sySdnc8OUfRL_2H_nZ2dnZfqlJ9g4p2d@giganews.com>
<afafbc24-9373-4686-ac19-909a06ffaf79n@googlegroups.com> <c3Sdnf2c2IG_-mH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<2b06c9cb-4cb3-4866-a4ad-a5e9f10a6270n@googlegroups.com> <h_qdnUg9Jqn282H_nZ2dnZfqlJzNnZ2d@giganews.com>
<92857281-cb53-4ddc-908a-50d2937c403en@googlegroups.com> <kyCdnWCxIsAqZGH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<772d0a3b-f170-40c0-8abb-6569ae6cc5d5n@googlegroups.com> <xvydnfdGtIaElWD_nZ2dnZfqlJzNnZ2d@giganews.com>
<0a36df55-771f-4f26-a073-4dc34ac69942n@googlegroups.com> <xZGdnWjVQ-X8kmD_nZ2dnZfqlJzNnZ2d@giganews.com>
<43abc3f8-279b-4eca-ac54-dbcf7b276db9n@googlegroups.com> <iMecnScwOYKViGD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<68e43e9f-8ac6-45c8-ae2d-54cf74c76787n@googlegroups.com> <0uWcnYwdfYD2gGD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<9ee5c99d-f30e-44d5-bdd9-e7213cfd8b16n@googlegroups.com> <buidnToEtpcwuGD_nZ2dnZfqlJzNnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <faff2ed1-3eb1-4c44-b394-4e4b8cf96785n@googlegroups.com>
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [stupid]
From: dbush.mo...@gmail.com (Dennis Bush)
Injection-Date: Wed, 17 Aug 2022 17:34:44 +0000
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
X-Received-Bytes: 12856
 by: Dennis Bush - Wed, 17 Aug 2022 17:34 UTC

On Wednesday, August 17, 2022 at 1:30:44 PM UTC-4, olcott wrote:
> On 8/17/2022 11:57 AM, Dennis Bush wrote:
> > On Wednesday, August 17, 2022 at 12:55:38 PM UTC-4, olcott wrote:
> >> On 8/17/2022 11:25 AM, Dennis Bush wrote:
> >>> On Wednesday, August 17, 2022 at 12:19:51 PM UTC-4, olcott wrote:
> >>>> On 8/17/2022 11:06 AM, Dennis Bush wrote:
> >>>>> On Wednesday, August 17, 2022 at 11:55:36 AM UTC-4, olcott wrote:
> >>>>>> On 8/17/2022 10:35 AM, Dennis Bush wrote:
> >>>>>>> On Wednesday, August 17, 2022 at 11:24:34 AM UTC-4, olcott wrote:
> >>>>>>>> On 8/17/2022 9:51 AM, Dennis Bush wrote:
> >>>>>>>>> On Wednesday, August 17, 2022 at 10:23:17 AM UTC-4, olcott wrote:
> >>>>>>>>>> On 8/17/2022 6:40 AM, Dennis Bush wrote:
> >>>>>>>>>>> On Wednesday, August 17, 2022 at 12:28:52 AM UTC-4, olcott wrote:
> >>>>>>>>>>>> On 8/16/2022 11:02 PM, Dennis Bush wrote:
> >>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:57:51 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>> On 8/16/2022 10:53 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:39:32 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>> On 8/16/2022 10:23 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:18:46 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>> On 8/16/2022 9:52 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:47:57 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:34 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:12:55 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 8:55 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On 8/16/22 9:20 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 8:10 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/22 10:27 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:07 AM, Skep Dick wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, 16 August 2022 at 15:55:30 UTC+2, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete x86 emulation of the input to H(P,P) by H
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> WOULD
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> never stop running.
> >>>>>>>>>>>>>>>>>>>>>>>>>>> Sounds like you are stuck in a loop.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> Maybe your Decider/Maker should terminate you..
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> I have been trying to get an honest person to acknowledge the
> >>>>>>>>>>>>>>>>>>>>>>>>>> correct software engineering of my system so that we can move on to
> >>>>>>>>>>>>>>>>>>>>>>>>>> the next point for a year now. (bot many honest people here, mostly
> >>>>>>>>>>>>>>>>>>>>>>>>>> trolls).
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> The problem is that what you say ISN'T CORRECT software engineering.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> You use the wrong definition of things and incorrect assumptions
> >>>>>>>>>>>>>>>>>>>>>>>>> about thing, so it just isn't true.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) does correctly predict that its correct and complete x86
> >>>>>>>>>>>>>>>>>>>>>>>>>> emulation of its input would never stop running, thus does correctly
> >>>>>>>>>>>>>>>>>>>>>>>>>> reject this input as non-halting.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> Nope. And in fact, you even acknoldge it doesn't but just don't see it.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> So you are saying that the correct and complete x86 emulation by
> >>>>>>>>>>>>>>>>>>>>>>>> H(P,P) of its input WOULD STOP RUNNING?
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> No, I am saying that you H doesn't do a correct and complete emulation
> >>>>>>>>>>>>>>>>>>>>>>> of its input, and thus to say it did is just a LIE.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> I said that H correctly predicts what the behavior of its correct and
> >>>>>>>>>>>>>>>>>>>>>> complete x86 emulation of H(P,P) would be
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> The fixed source code of H (and everything it calls) that aborts is Ha. Ha *always* aborts Pa, so "the correct and complete simulation of Ha(Pa,Pa)" does not exist, just like the shoes that Napoleon wore on Mars do not exist.
> >>>>>>>>>>>>>>>>>>>> So you are another brain dead moron the believes it is utterly
> >>>>>>>>>>>>>>>>>>>> impossible for H to correctly predict that its correct and complete x86
> >>>>>>>>>>>>>>>>>>>> emulation of its input would never stop running unless H actually
> >>>>>>>>>>>>>>>>>>>> performed a correct and complete emulation of its input.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> The correct and complete emulation of Ha(Pa,Pa) doesn't exist,
> >>>>>>>>>>>>>>>>>> Neither does the correct and complete emulation of Infinite_Loop()
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Yes it does. If you simulate Infinite_Loop(), it won't halt. But if you run Ha(Pa,Pa), it won't do a correct and complete simulation because it aborts.
> >>>>>>>>>>>>>>>> When you run H0((u32)Infinite_Loop)
> >>>>>>>>>>>>>>>> "it won't do a correct and complete simulation because it aborts"
> >>>>>>>>>>>>>>>> How long are you going to keep the head game up?
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> That you don't understand what I'm saying doesn't make it a head game.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>> You reject Ha(Pa,Pa) on this basis
> >>>>>>>>>>>>>> run Ha(Pa,Pa), it won't do a correct and complete simulation because it
> >>>>>>>>>>>>>> aborts.
> >>>>>>>>>>>>>> Yet accept P0(Infinite_Loop), on the same basis
> >>>>>>>>>>>>>> it won't do a correct and complete simulation because it aborts.
> >>>>>>>>>>>>>> ∴ You are playing head games.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> What does P0 do? Does it abort? If so, then yes P0(Infinite_Loop) doesn't do a correct and complete simulation because it aborts, so it's invalid to predict what the correct and complete simulation of P0(Infinite_Loop) would do.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> On the other hand, UTM(Infinite_Loop) does do a correct and complete simulation, so it *is* valid to predict what it will do.
> >>>>>>>>>>>>>
> >>>>>>>>>>>> In other words you are not bright enough to see that it is very easy for
> >>>>>>>>>>>> H0 to recognize an infinite loop would never halt in a finite number of
> >>>>>>>>>>>> steps of simulation?
> >>>>>>>>>>>
> >>>>>>>>>>> I'm saying that H0 can see that the correct and complete simulation performed by UTM(Infinite_Loop) does not halt. It does not and cannot see that the correct and complete simulation performed by H0(Infinite_Loop) (i.e. your basis for correctness) does not halt because H0 does not perform a correct and complete simulation.
> >>>>>>>>>>>
> >>>>>>>>>> This is what I mean by H evaluating what its correct and complete
> >>>>>>>>>> simulation of its input would be:
> >>>>>>>>>>
> >>>>>>>>>> void P(ptr x)
> >>>>>>>>>> {
> >>>>>>>>>> int Halt_Status = Simulate(x, x);
> >>>>>>>>>> if (Halt_Status)
> >>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>> return;
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> Although H itself does not perform a correct and complete simulation of
> >>>>>>>>>> non-halting inputs H does correctly predict that such a simulation would
> >>>>>>>>>> never halt.
> >>>>>>>>>
> >>>>>>>>> You changed the input from Pa to Pn.
> >>>>>>>>>
> >>>>>>>>> So you're again saying that Ha(Pa,Pa) reports the halt status of the non-input Pn(Pn) instead of Pa(Pa) as it is required to:
> >>>>>>>>>
> >>>>>>>> H0(Infinite_Loop)
> >>>>>>>> reports on Simulate(Infinite_Loop)
> >>>>>>>>
> >>>>>>>> H(Infinite_Recursion, 0x777)
> >>>>>>>> reports on Simulate((Infinite_Recursion, 0x777)
> >>>>>>>>
> >>>>>>>> In every case a simulating halt decider reports on what the behavior of
> >>>>>>>> its simulated input would be if this SHD was swapped for a simulator.
> >>>>>>>
> >>>>>>> And in the case of Ha(Pa,Pa) you change the input in doing so which is not allowed. Remember, what is being decided on is the FIXED source code of Pa and everything it calls, which includes the FIXED source code of Ha and everything it calls.
> >>>>>> THIS JUST SEEMS OVER YOUR HEAD.
> >>>>>> H correctly determines that its input would never halt by correctly
> >>>>>> predicting that its input would never halt if H never aborted its
> >>>>>> simulation of this input.
> >>>>>
> >>>>> Which is not what it is required to do if it claims to be a halt decider:
> >>>>>
> >>>>> For *any* algorithm X and input Y:
> >>>>> H(X,Y)==1 if and only if X(Y) halts, and
> >>>>> H(X,Y)==0 if and only if X(Y) does not halt
> >>>>>
> >>>> This is based on the false assumption that the actual behavior of the
> >>>> actual input is the same behavior as X(Y).
> >>>
> >>> FALSE, because it is the behavior of the direct execution that is being asked about.
> >> So you disagree that every decider must base its decision on a semantic
> >> or syntactic property of its input?
> >>
> >> In other words you are asserting that a decider must base its decision
> >> on a semantic or syntactic property of a non-input?
> >
> > You're the one asserting that, as you think that Ha(Pa,Pa) should be reporting the halt status of Pn(Pn):
> >
> A simulating halt decider always reports on what the behavior of its
> pure simulation of its input would be on the basis of recognizing an
> infinite behavior pattern that correctly predicts what the behavior of
> this pure simulation would be without the need to actually perform this
> pure simulation.


Click here to read the complete article
Re: Here is what a computer scientist that has been published in CACM said about my work [stupid]

<20220817183552.00003ac2@reddwarf.jmc.corp>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!npeer.as286.net!npeer-ng0.as286.net!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx12.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc.corp (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Here is what a computer scientist that has been published in
CACM said about my work [stupid]
Message-ID: <20220817183552.00003ac2@reddwarf.jmc.corp>
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<sySdnc8OUfRL_2H_nZ2dnZfqlJ9g4p2d@giganews.com>
<afafbc24-9373-4686-ac19-909a06ffaf79n@googlegroups.com>
<c3Sdnf2c2IG_-mH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<2b06c9cb-4cb3-4866-a4ad-a5e9f10a6270n@googlegroups.com>
<h_qdnUg9Jqn282H_nZ2dnZfqlJzNnZ2d@giganews.com>
<92857281-cb53-4ddc-908a-50d2937c403en@googlegroups.com>
<kyCdnWCxIsAqZGH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<772d0a3b-f170-40c0-8abb-6569ae6cc5d5n@googlegroups.com>
<xvydnfdGtIaElWD_nZ2dnZfqlJzNnZ2d@giganews.com>
<0a36df55-771f-4f26-a073-4dc34ac69942n@googlegroups.com>
<xZGdnWjVQ-X8kmD_nZ2dnZfqlJzNnZ2d@giganews.com>
<43abc3f8-279b-4eca-ac54-dbcf7b276db9n@googlegroups.com>
<iMecnScwOYKViGD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<68e43e9f-8ac6-45c8-ae2d-54cf74c76787n@googlegroups.com>
<0uWcnYwdfYD2gGD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<9ee5c99d-f30e-44d5-bdd9-e7213cfd8b16n@googlegroups.com>
<buidnToEtpcwuGD_nZ2dnZfqlJzNnZ2d@giganews.com>
Organization: Jupiter Mining Corporation
X-Newsreader: Claws Mail 4.1.0 (GTK 3.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 222
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Wed, 17 Aug 2022 17:35:52 UTC
Date: Wed, 17 Aug 2022 18:35:52 +0100
X-Received-Bytes: 13269
 by: Mr Flibble - Wed, 17 Aug 2022 17:35 UTC

On Wed, 17 Aug 2022 12:30:38 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/17/2022 11:57 AM, Dennis Bush wrote:
> > On Wednesday, August 17, 2022 at 12:55:38 PM UTC-4, olcott wrote:
> >> On 8/17/2022 11:25 AM, Dennis Bush wrote:
> >>> On Wednesday, August 17, 2022 at 12:19:51 PM UTC-4, olcott wrote:
> >>>
> >>>> On 8/17/2022 11:06 AM, Dennis Bush wrote:
> >>>>> On Wednesday, August 17, 2022 at 11:55:36 AM UTC-4, olcott
> >>>>> wrote:
> >>>>>> On 8/17/2022 10:35 AM, Dennis Bush wrote:
> >>>>>>> On Wednesday, August 17, 2022 at 11:24:34 AM UTC-4, olcott
> >>>>>>> wrote:
> >>>>>>>> On 8/17/2022 9:51 AM, Dennis Bush wrote:
> >>>>>>>>> On Wednesday, August 17, 2022 at 10:23:17 AM UTC-4, olcott
> >>>>>>>>> wrote:
> >>>>>>>>>> On 8/17/2022 6:40 AM, Dennis Bush wrote:
> >>>>>>>>>>> On Wednesday, August 17, 2022 at 12:28:52 AM UTC-4,
> >>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>> On 8/16/2022 11:02 PM, Dennis Bush wrote:
> >>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:57:51 PM UTC-4,
> >>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>> On 8/16/2022 10:53 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:39:32 PM UTC-4,
> >>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>> On 8/16/2022 10:23 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:18:46 PM UTC-4,
> >>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>> On 8/16/2022 9:52 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:47:57 PM UTC-4,
> >>>>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:34 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:12:55 PM
> >>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 8:55 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On 8/16/22 9:20 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 8:10 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/22 10:27 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:07 AM, Skep Dick wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, 16 August 2022 at 15:55:30
> >>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+2, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete x86 emulation
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> of the input to H(P,P) by H WOULD
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> never stop running.
> >>>>>>>>>>>>>>>>>>>>>>>>>>> Sounds like you are stuck in a loop.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> Maybe your Decider/Maker should terminate
> >>>>>>>>>>>>>>>>>>>>>>>>>>> you.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> I have been trying to get an honest person
> >>>>>>>>>>>>>>>>>>>>>>>>>> to acknowledge the correct software
> >>>>>>>>>>>>>>>>>>>>>>>>>> engineering of my system so that we can
> >>>>>>>>>>>>>>>>>>>>>>>>>> move on to the next point for a year now.
> >>>>>>>>>>>>>>>>>>>>>>>>>> (bot many honest people here, mostly
> >>>>>>>>>>>>>>>>>>>>>>>>>> trolls).
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> The problem is that what you say ISN'T
> >>>>>>>>>>>>>>>>>>>>>>>>> CORRECT software engineering.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> You use the wrong definition of things and
> >>>>>>>>>>>>>>>>>>>>>>>>> incorrect assumptions about thing, so it
> >>>>>>>>>>>>>>>>>>>>>>>>> just isn't true.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) does correctly predict that its
> >>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of its
> >>>>>>>>>>>>>>>>>>>>>>>>>> input would never stop running, thus does
> >>>>>>>>>>>>>>>>>>>>>>>>>> correctly reject this input as
> >>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> Nope. And in fact, you even acknoldge it
> >>>>>>>>>>>>>>>>>>>>>>>>> doesn't but just don't see it.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> So you are saying that the correct and
> >>>>>>>>>>>>>>>>>>>>>>>> complete x86 emulation by H(P,P) of its
> >>>>>>>>>>>>>>>>>>>>>>>> input WOULD STOP RUNNING?
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> No, I am saying that you H doesn't do a
> >>>>>>>>>>>>>>>>>>>>>>> correct and complete emulation of its input,
> >>>>>>>>>>>>>>>>>>>>>>> and thus to say it did is just a LIE.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> I said that H correctly predicts what the
> >>>>>>>>>>>>>>>>>>>>>> behavior of its correct and complete x86
> >>>>>>>>>>>>>>>>>>>>>> emulation of H(P,P) would be
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> The fixed source code of H (and everything it
> >>>>>>>>>>>>>>>>>>>>> calls) that aborts is Ha. Ha *always* aborts
> >>>>>>>>>>>>>>>>>>>>> Pa, so "the correct and complete simulation of
> >>>>>>>>>>>>>>>>>>>>> Ha(Pa,Pa)" does not exist, just like the shoes
> >>>>>>>>>>>>>>>>>>>>> that Napoleon wore on Mars do not exist.
> >>>>>>>>>>>>>>>>>>>> So you are another brain dead moron the believes
> >>>>>>>>>>>>>>>>>>>> it is utterly impossible for H to correctly
> >>>>>>>>>>>>>>>>>>>> predict that its correct and complete x86
> >>>>>>>>>>>>>>>>>>>> emulation of its input would never stop running
> >>>>>>>>>>>>>>>>>>>> unless H actually performed a correct and
> >>>>>>>>>>>>>>>>>>>> complete emulation of its input.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> The correct and complete emulation of Ha(Pa,Pa)
> >>>>>>>>>>>>>>>>>>> doesn't exist,
> >>>>>>>>>>>>>>>>>> Neither does the correct and complete emulation of
> >>>>>>>>>>>>>>>>>> Infinite_Loop()
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Yes it does. If you simulate Infinite_Loop(), it
> >>>>>>>>>>>>>>>>> won't halt. But if you run Ha(Pa,Pa), it won't do a
> >>>>>>>>>>>>>>>>> correct and complete simulation because it aborts.
> >>>>>>>>>>>>>>>> When you run H0((u32)Infinite_Loop)
> >>>>>>>>>>>>>>>> "it won't do a correct and complete simulation
> >>>>>>>>>>>>>>>> because it aborts" How long are you going to keep
> >>>>>>>>>>>>>>>> the head game up?
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> That you don't understand what I'm saying doesn't
> >>>>>>>>>>>>>>> make it a head game.
> >>>>>>>>>>>>>> You reject Ha(Pa,Pa) on this basis
> >>>>>>>>>>>>>> run Ha(Pa,Pa), it won't do a correct and complete
> >>>>>>>>>>>>>> simulation because it aborts.
> >>>>>>>>>>>>>> Yet accept P0(Infinite_Loop), on the same basis
> >>>>>>>>>>>>>> it won't do a correct and complete simulation because
> >>>>>>>>>>>>>> it aborts. ∴ You are playing head games.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> What does P0 do? Does it abort? If so, then yes
> >>>>>>>>>>>>> P0(Infinite_Loop) doesn't do a correct and complete
> >>>>>>>>>>>>> simulation because it aborts, so it's invalid to
> >>>>>>>>>>>>> predict what the correct and complete simulation of
> >>>>>>>>>>>>> P0(Infinite_Loop) would do.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> On the other hand, UTM(Infinite_Loop) does do a correct
> >>>>>>>>>>>>> and complete simulation, so it *is* valid to predict
> >>>>>>>>>>>>> what it will do.
> >>>>>>>>>>>> In other words you are not bright enough to see that it
> >>>>>>>>>>>> is very easy for H0 to recognize an infinite loop would
> >>>>>>>>>>>> never halt in a finite number of steps of simulation?
> >>>>>>>>>>>
> >>>>>>>>>>> I'm saying that H0 can see that the correct and complete
> >>>>>>>>>>> simulation performed by UTM(Infinite_Loop) does not halt.
> >>>>>>>>>>> It does not and cannot see that the correct and complete
> >>>>>>>>>>> simulation performed by H0(Infinite_Loop) (i.e. your
> >>>>>>>>>>> basis for correctness) does not halt because H0 does not
> >>>>>>>>>>> perform a correct and complete simulation.
> >>>>>>>>>> This is what I mean by H evaluating what its correct and
> >>>>>>>>>> complete simulation of its input would be:
> >>>>>>>>>>
> >>>>>>>>>> void P(ptr x)
> >>>>>>>>>> {
> >>>>>>>>>> int Halt_Status = Simulate(x, x);
> >>>>>>>>>> if (Halt_Status)
> >>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>> return;
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> Although H itself does not perform a correct and complete
> >>>>>>>>>> simulation of non-halting inputs H does correctly predict
> >>>>>>>>>> that such a simulation would never halt.
> >>>>>>>>>
> >>>>>>>>> You changed the input from Pa to Pn.
> >>>>>>>>>
> >>>>>>>>> So you're again saying that Ha(Pa,Pa) reports the halt
> >>>>>>>>> status of the non-input Pn(Pn) instead of Pa(Pa) as it is
> >>>>>>>>> required to:
> >>>>>>>> H0(Infinite_Loop)
> >>>>>>>> reports on Simulate(Infinite_Loop)
> >>>>>>>>
> >>>>>>>> H(Infinite_Recursion, 0x777)
> >>>>>>>> reports on Simulate((Infinite_Recursion, 0x777)
> >>>>>>>>
> >>>>>>>> In every case a simulating halt decider reports on what the
> >>>>>>>> behavior of its simulated input would be if this SHD was
> >>>>>>>> swapped for a simulator.
> >>>>>>>
> >>>>>>> And in the case of Ha(Pa,Pa) you change the input in doing so
> >>>>>>> which is not allowed. Remember, what is being decided on is
> >>>>>>> the FIXED source code of Pa and everything it calls, which
> >>>>>>> includes the FIXED source code of Ha and everything it calls.
> >>>>>>>
> >>>>>> THIS JUST SEEMS OVER YOUR HEAD.
> >>>>>> H correctly determines that its input would never halt by
> >>>>>> correctly predicting that its input would never halt if H
> >>>>>> never aborted its simulation of this input.
> >>>>>
> >>>>> Which is not what it is required to do if it claims to be a
> >>>>> halt decider:
> >>>>>
> >>>>> For *any* algorithm X and input Y:
> >>>>> H(X,Y)==1 if and only if X(Y) halts, and
> >>>>> H(X,Y)==0 if and only if X(Y) does not halt
> >>>>>
> >>>> This is based on the false assumption that the actual behavior
> >>>> of the actual input is the same behavior as X(Y).
> >>>
> >>> FALSE, because it is the behavior of the direct execution that is
> >>> being asked about.
> >> So you disagree that every decider must base its decision on a
> >> semantic or syntactic property of its input?
> >>
> >> In other words you are asserting that a decider must base its
> >> decision on a semantic or syntactic property of a non-input?
> >
> > You're the one asserting that, as you think that Ha(Pa,Pa) should
> > be reporting the halt status of Pn(Pn):
> A simulating halt decider always reports on what the behavior of its
> pure simulation of its input would be on the basis of recognizing an
> infinite behavior pattern that correctly predicts what the behavior
> of this pure simulation would be without the need to actually perform
> this pure simulation.


Click here to read the complete article
Re: Here is what a computer scientist that has been published in CACM said about my work [stupid]

<vLKdnaKL5cukumD_nZ2dnZfqlJ_NnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border-2.nntp.ord.giganews.com!border-1.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 17 Aug 2022 17:36:57 +0000
Date: Wed, 17 Aug 2022 12:37:19 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.12.0
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [stupid]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<sySdnc8OUfRL_2H_nZ2dnZfqlJ9g4p2d@giganews.com>
<afafbc24-9373-4686-ac19-909a06ffaf79n@googlegroups.com>
<c3Sdnf2c2IG_-mH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<2b06c9cb-4cb3-4866-a4ad-a5e9f10a6270n@googlegroups.com>
<h_qdnUg9Jqn282H_nZ2dnZfqlJzNnZ2d@giganews.com>
<92857281-cb53-4ddc-908a-50d2937c403en@googlegroups.com>
<kyCdnWCxIsAqZGH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<772d0a3b-f170-40c0-8abb-6569ae6cc5d5n@googlegroups.com>
<xvydnfdGtIaElWD_nZ2dnZfqlJzNnZ2d@giganews.com>
<0a36df55-771f-4f26-a073-4dc34ac69942n@googlegroups.com>
<xZGdnWjVQ-X8kmD_nZ2dnZfqlJzNnZ2d@giganews.com>
<43abc3f8-279b-4eca-ac54-dbcf7b276db9n@googlegroups.com>
<iMecnScwOYKViGD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<68e43e9f-8ac6-45c8-ae2d-54cf74c76787n@googlegroups.com>
<0uWcnYwdfYD2gGD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<9ee5c99d-f30e-44d5-bdd9-e7213cfd8b16n@googlegroups.com>
<IMOdnXoLpPFLvWD_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220817181602.00000ee2@reddwarf.jmc.corp>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220817181602.00000ee2@reddwarf.jmc.corp>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <vLKdnaKL5cukumD_nZ2dnZfqlJ_NnZ2d@giganews.com>
Lines: 246
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-76xsFd1uHEhczdBJ7wuReflLVjhLxLai3rp2kc1U154Kyfq2upiWyt3VVgir2BhBKomMm6zIxaG8ONf!Q8pGY89cZWIO+tKDvnqPQ5WlX/NCmwWl03S0lZ1t0FQDX4ZaRL0vpfSIBVteM7zGd5Syv/TViXY=
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
 by: olcott - Wed, 17 Aug 2022 17:37 UTC

On 8/17/2022 12:16 PM, Mr Flibble wrote:
> On Wed, 17 Aug 2022 12:09:59 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/17/2022 11:57 AM, Dennis Bush wrote:
>>> On Wednesday, August 17, 2022 at 12:55:38 PM UTC-4, olcott wrote:
>>>> On 8/17/2022 11:25 AM, Dennis Bush wrote:
>>>>> On Wednesday, August 17, 2022 at 12:19:51 PM UTC-4, olcott wrote:
>>>>>
>>>>>> On 8/17/2022 11:06 AM, Dennis Bush wrote:
>>>>>>> On Wednesday, August 17, 2022 at 11:55:36 AM UTC-4, olcott
>>>>>>> wrote:
>>>>>>>> On 8/17/2022 10:35 AM, Dennis Bush wrote:
>>>>>>>>> On Wednesday, August 17, 2022 at 11:24:34 AM UTC-4, olcott
>>>>>>>>> wrote:
>>>>>>>>>> On 8/17/2022 9:51 AM, Dennis Bush wrote:
>>>>>>>>>>> On Wednesday, August 17, 2022 at 10:23:17 AM UTC-4, olcott
>>>>>>>>>>> wrote:
>>>>>>>>>>>> On 8/17/2022 6:40 AM, Dennis Bush wrote:
>>>>>>>>>>>>> On Wednesday, August 17, 2022 at 12:28:52 AM UTC-4,
>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>> On 8/16/2022 11:02 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:57:51 PM UTC-4,
>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>> On 8/16/2022 10:53 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:39:32 PM UTC-4,
>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>> On 8/16/2022 10:23 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:18:46 PM UTC-4,
>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:52 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:47:57 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:34 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:12:55 PM
>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 8:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/22 9:20 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 8:10 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/22 10:27 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:07 AM, Skep Dick wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, 16 August 2022 at 15:55:30
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+2, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete x86 emulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the input to H(P,P) by H WOULD
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stop running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Sounds like you are stuck in a loop.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Maybe your Decider/Maker should terminate
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have been trying to get an honest person
>>>>>>>>>>>>>>>>>>>>>>>>>>>> to acknowledge the correct software
>>>>>>>>>>>>>>>>>>>>>>>>>>>> engineering of my system so that we can
>>>>>>>>>>>>>>>>>>>>>>>>>>>> move on to the next point for a year now.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> (bot many honest people here, mostly
>>>>>>>>>>>>>>>>>>>>>>>>>>>> trolls).
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> The problem is that what you say ISN'T
>>>>>>>>>>>>>>>>>>>>>>>>>>> CORRECT software engineering.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You use the wrong definition of things and
>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect assumptions about thing, so it
>>>>>>>>>>>>>>>>>>>>>>>>>>> just isn't true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) does correctly predict that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input would never stop running, thus does
>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly reject this input as
>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope. And in fact, you even acknoldge it
>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't but just don't see it.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> So you are saying that the correct and
>>>>>>>>>>>>>>>>>>>>>>>>>> complete x86 emulation by H(P,P) of its
>>>>>>>>>>>>>>>>>>>>>>>>>> input WOULD STOP RUNNING?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> No, I am saying that you H doesn't do a
>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete emulation of its input,
>>>>>>>>>>>>>>>>>>>>>>>>> and thus to say it did is just a LIE.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> I said that H correctly predicts what the
>>>>>>>>>>>>>>>>>>>>>>>> behavior of its correct and complete x86
>>>>>>>>>>>>>>>>>>>>>>>> emulation of H(P,P) would be
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The fixed source code of H (and everything it
>>>>>>>>>>>>>>>>>>>>>>> calls) that aborts is Ha. Ha *always* aborts
>>>>>>>>>>>>>>>>>>>>>>> Pa, so "the correct and complete simulation of
>>>>>>>>>>>>>>>>>>>>>>> Ha(Pa,Pa)" does not exist, just like the shoes
>>>>>>>>>>>>>>>>>>>>>>> that Napoleon wore on Mars do not exist.
>>>>>>>>>>>>>>>>>>>>>> So you are another brain dead moron the believes
>>>>>>>>>>>>>>>>>>>>>> it is utterly impossible for H to correctly
>>>>>>>>>>>>>>>>>>>>>> predict that its correct and complete x86
>>>>>>>>>>>>>>>>>>>>>> emulation of its input would never stop running
>>>>>>>>>>>>>>>>>>>>>> unless H actually performed a correct and
>>>>>>>>>>>>>>>>>>>>>> complete emulation of its input.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The correct and complete emulation of Ha(Pa,Pa)
>>>>>>>>>>>>>>>>>>>>> doesn't exist,
>>>>>>>>>>>>>>>>>>>> Neither does the correct and complete emulation of
>>>>>>>>>>>>>>>>>>>> Infinite_Loop()
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Yes it does. If you simulate Infinite_Loop(), it
>>>>>>>>>>>>>>>>>>> won't halt. But if you run Ha(Pa,Pa), it won't do a
>>>>>>>>>>>>>>>>>>> correct and complete simulation because it aborts.
>>>>>>>>>>>>>>>>>> When you run H0((u32)Infinite_Loop)
>>>>>>>>>>>>>>>>>> "it won't do a correct and complete simulation
>>>>>>>>>>>>>>>>>> because it aborts" How long are you going to keep
>>>>>>>>>>>>>>>>>> the head game up?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That you don't understand what I'm saying doesn't
>>>>>>>>>>>>>>>>> make it a head game.
>>>>>>>>>>>>>>>> You reject Ha(Pa,Pa) on this basis
>>>>>>>>>>>>>>>> run Ha(Pa,Pa), it won't do a correct and complete
>>>>>>>>>>>>>>>> simulation because it aborts.
>>>>>>>>>>>>>>>> Yet accept P0(Infinite_Loop), on the same basis
>>>>>>>>>>>>>>>> it won't do a correct and complete simulation because
>>>>>>>>>>>>>>>> it aborts. ∴ You are playing head games.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> What does P0 do? Does it abort? If so, then yes
>>>>>>>>>>>>>>> P0(Infinite_Loop) doesn't do a correct and complete
>>>>>>>>>>>>>>> simulation because it aborts, so it's invalid to
>>>>>>>>>>>>>>> predict what the correct and complete simulation of
>>>>>>>>>>>>>>> P0(Infinite_Loop) would do.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On the other hand, UTM(Infinite_Loop) does do a correct
>>>>>>>>>>>>>>> and complete simulation, so it *is* valid to predict
>>>>>>>>>>>>>>> what it will do.
>>>>>>>>>>>>>> In other words you are not bright enough to see that it
>>>>>>>>>>>>>> is very easy for H0 to recognize an infinite loop would
>>>>>>>>>>>>>> never halt in a finite number of steps of simulation?
>>>>>>>>>>>>>
>>>>>>>>>>>>> I'm saying that H0 can see that the correct and complete
>>>>>>>>>>>>> simulation performed by UTM(Infinite_Loop) does not halt.
>>>>>>>>>>>>> It does not and cannot see that the correct and complete
>>>>>>>>>>>>> simulation performed by H0(Infinite_Loop) (i.e. your
>>>>>>>>>>>>> basis for correctness) does not halt because H0 does not
>>>>>>>>>>>>> perform a correct and complete simulation.
>>>>>>>>>>>> This is what I mean by H evaluating what its correct and
>>>>>>>>>>>> complete simulation of its input would be:
>>>>>>>>>>>>
>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>> {
>>>>>>>>>>>> int Halt_Status = Simulate(x, x);
>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>> return;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> Although H itself does not perform a correct and complete
>>>>>>>>>>>> simulation of non-halting inputs H does correctly predict
>>>>>>>>>>>> that such a simulation would never halt.
>>>>>>>>>>>
>>>>>>>>>>> You changed the input from Pa to Pn.
>>>>>>>>>>>
>>>>>>>>>>> So you're again saying that Ha(Pa,Pa) reports the halt
>>>>>>>>>>> status of the non-input Pn(Pn) instead of Pa(Pa) as it is
>>>>>>>>>>> required to:
>>>>>>>>>> H0(Infinite_Loop)
>>>>>>>>>> reports on Simulate(Infinite_Loop)
>>>>>>>>>>
>>>>>>>>>> H(Infinite_Recursion, 0x777)
>>>>>>>>>> reports on Simulate((Infinite_Recursion, 0x777)
>>>>>>>>>>
>>>>>>>>>> In every case a simulating halt decider reports on what the
>>>>>>>>>> behavior of its simulated input would be if this SHD was
>>>>>>>>>> swapped for a simulator.
>>>>>>>>>
>>>>>>>>> And in the case of Ha(Pa,Pa) you change the input in doing so
>>>>>>>>> which is not allowed. Remember, what is being decided on is
>>>>>>>>> the FIXED source code of Pa and everything it calls, which
>>>>>>>>> includes the FIXED source code of Ha and everything it calls.
>>>>>>>>>
>>>>>>>> THIS JUST SEEMS OVER YOUR HEAD.
>>>>>>>> H correctly determines that its input would never halt by
>>>>>>>> correctly predicting that its input would never halt if H
>>>>>>>> never aborted its simulation of this input.
>>>>>>>
>>>>>>> Which is not what it is required to do if it claims to be a
>>>>>>> halt decider:
>>>>>>>
>>>>>>> For *any* algorithm X and input Y:
>>>>>>> H(X,Y)==1 if and only if X(Y) halts, and
>>>>>>> H(X,Y)==0 if and only if X(Y) does not halt
>>>>>>>
>>>>>> This is based on the false assumption that the actual behavior
>>>>>> of the actual input is the same behavior as X(Y).
>>>>>
>>>>> FALSE, because it is the behavior of the direct execution that is
>>>>> being asked about.
>>>> So you disagree that every decider must base its decision on a
>>>> semantic or syntactic property of its input?
>>>>
>>>> In other words you are asserting that a decider must base its
>>>> decision on a semantic or syntactic property of a non-input?
>>>
>>> You're the one asserting that, as you think that Ha(Pa,Pa) should
>>> be reporting the halt status of Pn(Pn):
>>
>> H is reporting on the behavior that these machine language bytes
>> specify:
>> 558bec518b4508508b4d0851e8bffeffff83c4088945fc837dfc007402ebfe8be55dc3
>>
>> _P()
>> [00000fc2](01) 55 push ebp
>> [00000fc3](02) 8bec mov ebp,esp
>> [00000fc5](01) 51 push ecx
>> [00000fc6](03) 8b4508 mov eax,[ebp+08]
>> [00000fc9](01) 50 push eax
>> [00000fca](03) 8b4d08 mov ecx,[ebp+08]
>> [00000fcd](01) 51 push ecx
>> [00000fce](05) e8bffeffff call 00000e92
>> [00000fd3](03) 83c408 add esp,+08
>> [00000fd6](03) 8945fc mov [ebp-04],eax
>> [00000fd9](04) 837dfc00 cmp dword [ebp-04],+00
>> [00000fdd](02) 7402 jz 00000fe1
>> [00000fdf](02) ebfe jmp 00000fdf
>> [00000fe1](02) 8be5 mov esp,ebp
>> [00000fe3](01) 5d pop ebp
>> [00000fe4](01) c3 ret
>> Size in bytes:(0035) [00000fe4]
>
> No it isn't, as you "abort the simulation" so it never reaches 00000fd3.
>
> /Flibble
>


Click here to read the complete article
Re: Here is what a computer scientist that has been published in CACM said about my work [stupid]

<20220817184101.0000578b@reddwarf.jmc.corp>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx12.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc.corp (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Here is what a computer scientist that has been published in
CACM said about my work [stupid]
Message-ID: <20220817184101.0000578b@reddwarf.jmc.corp>
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.com>
<c3Sdnf2c2IG_-mH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<2b06c9cb-4cb3-4866-a4ad-a5e9f10a6270n@googlegroups.com>
<h_qdnUg9Jqn282H_nZ2dnZfqlJzNnZ2d@giganews.com>
<92857281-cb53-4ddc-908a-50d2937c403en@googlegroups.com>
<kyCdnWCxIsAqZGH_nZ2dnZfqlJ_NnZ2d@giganews.com>
<772d0a3b-f170-40c0-8abb-6569ae6cc5d5n@googlegroups.com>
<xvydnfdGtIaElWD_nZ2dnZfqlJzNnZ2d@giganews.com>
<0a36df55-771f-4f26-a073-4dc34ac69942n@googlegroups.com>
<xZGdnWjVQ-X8kmD_nZ2dnZfqlJzNnZ2d@giganews.com>
<43abc3f8-279b-4eca-ac54-dbcf7b276db9n@googlegroups.com>
<iMecnScwOYKViGD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<68e43e9f-8ac6-45c8-ae2d-54cf74c76787n@googlegroups.com>
<0uWcnYwdfYD2gGD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<9ee5c99d-f30e-44d5-bdd9-e7213cfd8b16n@googlegroups.com>
<IMOdnXoLpPFLvWD_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220817181602.00000ee2@reddwarf.jmc.corp>
<vLKdnaKL5cukumD_nZ2dnZfqlJ_NnZ2d@giganews.com>
Organization: Jupiter Mining Corporation
X-Newsreader: Claws Mail 4.1.0 (GTK 3.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 255
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Wed, 17 Aug 2022 17:41:01 UTC
Date: Wed, 17 Aug 2022 18:41:01 +0100
X-Received-Bytes: 14882
 by: Mr Flibble - Wed, 17 Aug 2022 17:41 UTC

On Wed, 17 Aug 2022 12:37:19 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/17/2022 12:16 PM, Mr Flibble wrote:
> > On Wed, 17 Aug 2022 12:09:59 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 8/17/2022 11:57 AM, Dennis Bush wrote:
> >>> On Wednesday, August 17, 2022 at 12:55:38 PM UTC-4, olcott wrote:
> >>>
> >>>> On 8/17/2022 11:25 AM, Dennis Bush wrote:
> >>>>> On Wednesday, August 17, 2022 at 12:19:51 PM UTC-4, olcott
> >>>>> wrote:
> >>>>>> On 8/17/2022 11:06 AM, Dennis Bush wrote:
> >>>>>>> On Wednesday, August 17, 2022 at 11:55:36 AM UTC-4, olcott
> >>>>>>> wrote:
> >>>>>>>> On 8/17/2022 10:35 AM, Dennis Bush wrote:
> >>>>>>>>> On Wednesday, August 17, 2022 at 11:24:34 AM UTC-4, olcott
> >>>>>>>>> wrote:
> >>>>>>>>>> On 8/17/2022 9:51 AM, Dennis Bush wrote:
> >>>>>>>>>>> On Wednesday, August 17, 2022 at 10:23:17 AM UTC-4, olcott
> >>>>>>>>>>> wrote:
> >>>>>>>>>>>> On 8/17/2022 6:40 AM, Dennis Bush wrote:
> >>>>>>>>>>>>> On Wednesday, August 17, 2022 at 12:28:52 AM UTC-4,
> >>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>> On 8/16/2022 11:02 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:57:51 PM UTC-4,
> >>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>> On 8/16/2022 10:53 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:39:32 PM UTC-4,
> >>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>> On 8/16/2022 10:23 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:18:46 PM UTC-4,
> >>>>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:52 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:47:57 PM
> >>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:34 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:12:55 PM
> >>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 8:55 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/22 9:20 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 8:10 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/22 10:27 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:07 AM, Skep Dick wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, 16 August 2022 at 15:55:30
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+2, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete x86 emulation
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the input to H(P,P) by H WOULD
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stop running.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Sounds like you are stuck in a loop.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Maybe your Decider/Maker should
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate you.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> I have been trying to get an honest
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> person to acknowledge the correct
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> software engineering of my system so
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> that we can move on to the next point
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> for a year now. (bot many honest people
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> here, mostly trolls).
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> The problem is that what you say ISN'T
> >>>>>>>>>>>>>>>>>>>>>>>>>>> CORRECT software engineering.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> You use the wrong definition of things and
> >>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect assumptions about thing, so it
> >>>>>>>>>>>>>>>>>>>>>>>>>>> just isn't true.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) does correctly predict that its
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of its
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> input would never stop running, thus does
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly reject this input as
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> Nope. And in fact, you even acknoldge it
> >>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't but just don't see it.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> So you are saying that the correct and
> >>>>>>>>>>>>>>>>>>>>>>>>>> complete x86 emulation by H(P,P) of its
> >>>>>>>>>>>>>>>>>>>>>>>>>> input WOULD STOP RUNNING?
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> No, I am saying that you H doesn't do a
> >>>>>>>>>>>>>>>>>>>>>>>>> correct and complete emulation of its input,
> >>>>>>>>>>>>>>>>>>>>>>>>> and thus to say it did is just a LIE.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> I said that H correctly predicts what the
> >>>>>>>>>>>>>>>>>>>>>>>> behavior of its correct and complete x86
> >>>>>>>>>>>>>>>>>>>>>>>> emulation of H(P,P) would be
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> The fixed source code of H (and everything it
> >>>>>>>>>>>>>>>>>>>>>>> calls) that aborts is Ha. Ha *always* aborts
> >>>>>>>>>>>>>>>>>>>>>>> Pa, so "the correct and complete simulation of
> >>>>>>>>>>>>>>>>>>>>>>> Ha(Pa,Pa)" does not exist, just like the shoes
> >>>>>>>>>>>>>>>>>>>>>>> that Napoleon wore on Mars do not exist.
> >>>>>>>>>>>>>>>>>>>>>> So you are another brain dead moron the
> >>>>>>>>>>>>>>>>>>>>>> believes it is utterly impossible for H to
> >>>>>>>>>>>>>>>>>>>>>> correctly predict that its correct and
> >>>>>>>>>>>>>>>>>>>>>> complete x86 emulation of its input would
> >>>>>>>>>>>>>>>>>>>>>> never stop running unless H actually performed
> >>>>>>>>>>>>>>>>>>>>>> a correct and complete emulation of its input.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> The correct and complete emulation of Ha(Pa,Pa)
> >>>>>>>>>>>>>>>>>>>>> doesn't exist,
> >>>>>>>>>>>>>>>>>>>> Neither does the correct and complete emulation
> >>>>>>>>>>>>>>>>>>>> of Infinite_Loop()
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> Yes it does. If you simulate Infinite_Loop(), it
> >>>>>>>>>>>>>>>>>>> won't halt. But if you run Ha(Pa,Pa), it won't do
> >>>>>>>>>>>>>>>>>>> a correct and complete simulation because it
> >>>>>>>>>>>>>>>>>>> aborts.
> >>>>>>>>>>>>>>>>>> When you run H0((u32)Infinite_Loop)
> >>>>>>>>>>>>>>>>>> "it won't do a correct and complete simulation
> >>>>>>>>>>>>>>>>>> because it aborts" How long are you going to keep
> >>>>>>>>>>>>>>>>>> the head game up?
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> That you don't understand what I'm saying doesn't
> >>>>>>>>>>>>>>>>> make it a head game.
> >>>>>>>>>>>>>>>> You reject Ha(Pa,Pa) on this basis
> >>>>>>>>>>>>>>>> run Ha(Pa,Pa), it won't do a correct and complete
> >>>>>>>>>>>>>>>> simulation because it aborts.
> >>>>>>>>>>>>>>>> Yet accept P0(Infinite_Loop), on the same basis
> >>>>>>>>>>>>>>>> it won't do a correct and complete simulation because
> >>>>>>>>>>>>>>>> it aborts. ∴ You are playing head games.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> What does P0 do? Does it abort? If so, then yes
> >>>>>>>>>>>>>>> P0(Infinite_Loop) doesn't do a correct and complete
> >>>>>>>>>>>>>>> simulation because it aborts, so it's invalid to
> >>>>>>>>>>>>>>> predict what the correct and complete simulation of
> >>>>>>>>>>>>>>> P0(Infinite_Loop) would do.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> On the other hand, UTM(Infinite_Loop) does do a
> >>>>>>>>>>>>>>> correct and complete simulation, so it *is* valid to
> >>>>>>>>>>>>>>> predict what it will do.
> >>>>>>>>>>>>>> In other words you are not bright enough to see that it
> >>>>>>>>>>>>>> is very easy for H0 to recognize an infinite loop would
> >>>>>>>>>>>>>> never halt in a finite number of steps of simulation?
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> I'm saying that H0 can see that the correct and complete
> >>>>>>>>>>>>> simulation performed by UTM(Infinite_Loop) does not
> >>>>>>>>>>>>> halt. It does not and cannot see that the correct and
> >>>>>>>>>>>>> complete simulation performed by H0(Infinite_Loop)
> >>>>>>>>>>>>> (i.e. your basis for correctness) does not halt because
> >>>>>>>>>>>>> H0 does not perform a correct and complete simulation.
> >>>>>>>>>>>> This is what I mean by H evaluating what its correct and
> >>>>>>>>>>>> complete simulation of its input would be:
> >>>>>>>>>>>>
> >>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>> {
> >>>>>>>>>>>> int Halt_Status = Simulate(x, x);
> >>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>> return;
> >>>>>>>>>>>> }
> >>>>>>>>>>>>
> >>>>>>>>>>>> Although H itself does not perform a correct and complete
> >>>>>>>>>>>> simulation of non-halting inputs H does correctly predict
> >>>>>>>>>>>> that such a simulation would never halt.
> >>>>>>>>>>>
> >>>>>>>>>>> You changed the input from Pa to Pn.
> >>>>>>>>>>>
> >>>>>>>>>>> So you're again saying that Ha(Pa,Pa) reports the halt
> >>>>>>>>>>> status of the non-input Pn(Pn) instead of Pa(Pa) as it is
> >>>>>>>>>>> required to:
> >>>>>>>>>> H0(Infinite_Loop)
> >>>>>>>>>> reports on Simulate(Infinite_Loop)
> >>>>>>>>>>
> >>>>>>>>>> H(Infinite_Recursion, 0x777)
> >>>>>>>>>> reports on Simulate((Infinite_Recursion, 0x777)
> >>>>>>>>>>
> >>>>>>>>>> In every case a simulating halt decider reports on what the
> >>>>>>>>>> behavior of its simulated input would be if this SHD was
> >>>>>>>>>> swapped for a simulator.
> >>>>>>>>>
> >>>>>>>>> And in the case of Ha(Pa,Pa) you change the input in doing
> >>>>>>>>> so which is not allowed. Remember, what is being decided on
> >>>>>>>>> is the FIXED source code of Pa and everything it calls,
> >>>>>>>>> which includes the FIXED source code of Ha and everything
> >>>>>>>>> it calls.
> >>>>>>>> THIS JUST SEEMS OVER YOUR HEAD.
> >>>>>>>> H correctly determines that its input would never halt by
> >>>>>>>> correctly predicting that its input would never halt if H
> >>>>>>>> never aborted its simulation of this input.
> >>>>>>>
> >>>>>>> Which is not what it is required to do if it claims to be a
> >>>>>>> halt decider:
> >>>>>>>
> >>>>>>> For *any* algorithm X and input Y:
> >>>>>>> H(X,Y)==1 if and only if X(Y) halts, and
> >>>>>>> H(X,Y)==0 if and only if X(Y) does not halt
> >>>>>>>
> >>>>>> This is based on the false assumption that the actual behavior
> >>>>>> of the actual input is the same behavior as X(Y).
> >>>>>
> >>>>> FALSE, because it is the behavior of the direct execution that
> >>>>> is being asked about.
> >>>> So you disagree that every decider must base its decision on a
> >>>> semantic or syntactic property of its input?
> >>>>
> >>>> In other words you are asserting that a decider must base its
> >>>> decision on a semantic or syntactic property of a non-input?
> >>>
> >>> You're the one asserting that, as you think that Ha(Pa,Pa) should
> >>> be reporting the halt status of Pn(Pn):
> >>
> >> H is reporting on the behavior that these machine language bytes
> >> specify:
> >> 558bec518b4508508b4d0851e8bffeffff83c4088945fc837dfc007402ebfe8be55dc3
> >>
> >> _P()
> >> [00000fc2](01) 55 push ebp
> >> [00000fc3](02) 8bec mov ebp,esp
> >> [00000fc5](01) 51 push ecx
> >> [00000fc6](03) 8b4508 mov eax,[ebp+08]
> >> [00000fc9](01) 50 push eax
> >> [00000fca](03) 8b4d08 mov ecx,[ebp+08]
> >> [00000fcd](01) 51 push ecx
> >> [00000fce](05) e8bffeffff call 00000e92
> >> [00000fd3](03) 83c408 add esp,+08
> >> [00000fd6](03) 8945fc mov [ebp-04],eax
> >> [00000fd9](04) 837dfc00 cmp dword [ebp-04],+00
> >> [00000fdd](02) 7402 jz 00000fe1
> >> [00000fdf](02) ebfe jmp 00000fdf
> >> [00000fe1](02) 8be5 mov esp,ebp
> >> [00000fe3](01) 5d pop ebp
> >> [00000fe4](01) c3 ret
> >> Size in bytes:(0035) [00000fe4]
> >
> > No it isn't, as you "abort the simulation" so it never reaches
> > 00000fd3.
> >
> > /Flibble
> >
>
> Even though you claim to be a computer scientist you have proven that
> you do not sufficiently understand the idea of unreachable code in
> that the correctly simulated input to H(P,P) can never reach past
> [00000fca] whether its simulation has been aborted or not.
>
> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
> (b) that simulates P(P) that calls a simulated H(P,P)
> (c) that simulates P(P) that calls a simulated H(P,P)
> (d) that simulates P(P) that calls a simulated H(P,P)...
> *Until H aborts its simulation*


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

rocksolid light 0.9.8
clearnet tor