Welcome to novaBBS (click a section below)

mail files register newsreader groups login

Message-ID:

REST: P: Linus Torvalds S: Buried alive in email -- from /usr/src/linux/MAINTAINERS

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

Subject	Author
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in	Mr Flibble
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in	Mr Flibble
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in	Mr Flibble
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in	Mr Flibble
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in	Mr Flibble
Here is what a computer scientist that has been published in CACM	Richard Damon
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Richard Damon
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Richard Damon
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Richard Damon
Here is what a computer scientist that has been published in CACM	d thiebaud
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in	Mr Flibble
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Richard Damon
Here is what a computer scientist that has been published in CACM	Skep Dick
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Richard Harnden
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in	Mr Flibble
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in	Mr Flibble
Here is what a computer scientist that has been published in	olcott
Here is what a computer scientist that has been published in CACM	Richard Damon
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Richard Damon
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Richard Damon
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Richard Damon
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Richard Damon
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Richard Damon
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Richard Damon
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Richard Damon
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Richard Damon
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Richard Damon
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Richard Damon
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Richard Damon
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Richard Damon
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Richard Damon
Here is what a computer scientist that has been published in CACM	Skep Dick
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Skep Dick
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Richard Damon
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Richard Damon
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Richard Damon
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Dennis Bush
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Dennis Bush
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Dennis Bush
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Dennis Bush
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Dennis Bush
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Dennis 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 CACM	Dennis 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 CACM	Dennis Bush
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Dennis Bush
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Dennis 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 CACM	Dennis Bush
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in	Mr Flibble
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in	Mr Flibble
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in	Mr Flibble
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in	Mr Flibble
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in	Mr Flibble
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in	Mr Flibble
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	Dennis Bush
Here is what a computer scientist that has been published in CACM	Dennis Bush
Here is what a computer scientist that has been published in CACM	Richard Damon
Here is what a computer scientist that has been published in CACM	dklei...@gmail.com
Here is what a computer scientist that has been published in CACM	Skep Dick
Here is what a computer scientist that has been published in CACM	olcott
Here is what a computer scientist that has been published in CACM	olcott

Pages:1 2 3 4 5 678 9 10

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

<KaudnSE1cOxGtWD_nZ2dnZfqlJ_NnZ2d@giganews.com>

copy mid

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

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 17:43:55 +0000
Date: Wed, 17 Aug 2022 12:44:17 -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>
<buidnToEtpcwuGD_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220817183552.00003ac2@reddwarf.jmc.corp>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220817183552.00003ac2@reddwarf.jmc.corp>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <KaudnSE1cOxGtWD_nZ2dnZfqlJ_NnZ2d@giganews.com>
Lines: 217
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-FSXcTReHYMhrzbxJ3miPFtxObnUAPbiFQCE9fBMKwvuHPZV+s0go/Qj1U3SmaUASofcaRjQyphzA2Sj!Dxoa1UEGsolCwSgRQs46HpIjl3kkynrUZXnmk9kgECrHZMOtcbt3KbExMrgdEAviW1RKxkzmpzA=
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:44 UTC

On 8/17/2022 12:35 PM, Mr Flibble wrote:
> 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.
>
> Not when the infinite behaviour is a property of the decider itself as

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]

<KaudnSA1cOxbtGD_nZ2dnZfqlJ9g4p2d@giganews.com>

copy mid

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

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:47:50 +0000
Date: Wed, 17 Aug 2022 12:48:12 -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>
<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>
<20220817184101.0000578b@reddwarf.jmc.corp>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220817184101.0000578b@reddwarf.jmc.corp>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <KaudnSA1cOxbtGD_nZ2dnZfqlJ9g4p2d@giganews.com>
Lines: 269
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-k7rksjufhFBIlN/++0BB3IMvLYs7XPoed+BmHQ/8RoMHDXx25fVqsafYDK7LOtfGZg2Y4g4qUOwbnob!0qr4jxR88HrMGHAf6G2e+OlohHBPbj+HapKEzsQ4L/GFusFwS6rOajUX6URCxcE9JPYCXyxLRbk=
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:48 UTC

On 8/17/2022 12:41 PM, Mr Flibble wrote:
> 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*
>
> You are either deluded or a liar, which is it? I am a computer
> scientist and I have pointed out your mistakes over and over again
> including in the reply in this thread. The code is only "unreachable"
> because you abort the simulation as you couldn't come up with a
> solution that avoids infinite recursion (like I did).
>
> /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]

<20220817184926.000030e0@reddwarf.jmc.corp>

copy mid

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

copy link Newsgroups: comp.theory

Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx06.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: <20220817184926.000030e0@reddwarf.jmc.corp>
References: <VUmdneqWu_jdjGT_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>
<20220817184101.0000578b@reddwarf.jmc.corp>
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=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 19
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Wed, 17 Aug 2022 17:49:26 UTC
Date: Wed, 17 Aug 2022 18:49:26 +0100
X-Received-Bytes: 2411

by: Mr Flibble - Wed, 17 Aug 2022 17:49 UTC

On Wed, 17 Aug 2022 18:41:01 +0100
Mr Flibble <flibble@reddwarf.jmc.corp> wrote:

> > >> H is reporting on the behavior that these machine language bytes
> > >> specify:
> > >> 558bec518b4508508b4d0851e8bffeffff83c4088945fc837dfc007402ebfe8be55dc3

If you are treating the "machine language bytes" after 00000fd2 as
"unreachable" then you are NOT reporting on the behaviour of those
"machine language bytes", you are instead reporting on the subset

558bec518b4508508b4d0851e8bffeffff

If you are only reporting on part of P rather than all of P then you are
not reporting on the behaviour of P. You are either too stupid to
understand this or you do understand this and are a bare faced liar.

/Flibble

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

<20220817185332.000055a8@reddwarf.jmc.corp>

copy mid

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

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!peer03.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx06.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: <20220817185332.000055a8@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>
<buidnToEtpcwuGD_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220817183552.00003ac2@reddwarf.jmc.corp>
<KaudnSE1cOxGtWD_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: 226
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Wed, 17 Aug 2022 17:53:32 UTC
Date: Wed, 17 Aug 2022 18:53:32 +0100
X-Received-Bytes: 13618

by: Mr Flibble - Wed, 17 Aug 2022 17:53 UTC

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

> On 8/17/2022 12:35 PM, Mr Flibble wrote:
> > 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.
> >
> > Not when the infinite behaviour is a property of the decider itself
> > as
>
> It superficially seems like the behavior of H(P,P) is mutual infinite
> recursion until you realize the H is merely mimicking the behavior
> that P specifies.

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]

<dL-dnb-VKthBsGD_nZ2dnZfqlJzNnZ2d@giganews.com>

copy mid

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

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 18:05:16 +0000
Date: Wed, 17 Aug 2022 13:05:33 -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>
<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>
<20220817183552.00003ac2@reddwarf.jmc.corp>
<KaudnSE1cOxGtWD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220817185332.000055a8@reddwarf.jmc.corp>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220817185332.000055a8@reddwarf.jmc.corp>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <dL-dnb-VKthBsGD_nZ2dnZfqlJzNnZ2d@giganews.com>
Lines: 233
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-founWBs5IJDDdjswKKhSwHAwGUckZ5YLPI1X0J2X/r8yCqkg0vSOK43jvMCdyMM1M30W4QVJIKsVreE!g4cxFTdEJy3+NlDiJpkEpnNpW2gFGea02jx87Ax085n6kt1MGlPDNbx5k5y1OTu04OvvsGxeBtY=
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 18:05 UTC

On 8/17/2022 12:53 PM, Mr Flibble wrote:
> On Wed, 17 Aug 2022 12:44:17 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/17/2022 12:35 PM, Mr Flibble wrote:
>>> 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.
>>>
>>> Not when the infinite behaviour is a property of the decider itself
>>> as
>>
>> It superficially seems like the behavior of H(P,P) is mutual infinite
>> recursion until you realize the H is merely mimicking the behavior
>> that P specifies.
>
> FALSE. P is NOT recursive, your H is recursive, this is plainly obvious
> to everyone except you.

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]

<20220817190914.00000957@reddwarf.jmc.corp>

copy mid

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

copy link Newsgroups: comp.theory

Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx02.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: <20220817190914.00000957@reddwarf.jmc.corp>
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@giganews.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>
<20220817183552.00003ac2@reddwarf.jmc.corp>
<KaudnSE1cOxGtWD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220817185332.000055a8@reddwarf.jmc.corp>
<dL-dnb-VKthBsGD_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: 245
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Wed, 17 Aug 2022 18:09:14 UTC
Date: Wed, 17 Aug 2022 19:09:14 +0100
X-Received-Bytes: 14731

by: Mr Flibble - Wed, 17 Aug 2022 18:09 UTC

On Wed, 17 Aug 2022 13:05:33 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/17/2022 12:53 PM, Mr Flibble wrote:
> > On Wed, 17 Aug 2022 12:44:17 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 8/17/2022 12:35 PM, Mr Flibble wrote:
> >>> 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.
> >>>
> >>> Not when the infinite behaviour is a property of the decider
> >>> itself as
> >>
> >> It superficially seems like the behavior of H(P,P) is mutual
> >> infinite recursion until you realize the H is merely mimicking the
> >> behavior that P specifies.
> >
> > FALSE. P is NOT recursive, your H is recursive, this is plainly
> > obvious to everyone except you.
>
> My key unique discovery (back in 2016) was that every conventional
> "pathological" input used to prove that the HP cannot be solved
> specifies infinitely recursive simulation to every simulating halt
> decider.

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]

<5bqdnbEipbUmsmD_nZ2dnZfqlJxh4p2d@giganews.com>

copy mid

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

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 18:13:15 +0000
Date: Wed, 17 Aug 2022 13:13:32 -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>
<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>
<20220817183552.00003ac2@reddwarf.jmc.corp>
<KaudnSE1cOxGtWD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220817185332.000055a8@reddwarf.jmc.corp>
<dL-dnb-VKthBsGD_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220817190914.00000957@reddwarf.jmc.corp>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220817190914.00000957@reddwarf.jmc.corp>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <5bqdnbEipbUmsmD_nZ2dnZfqlJxh4p2d@giganews.com>
Lines: 259
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-q5d6z215lKPeG09W/x3raSqfeZMeM1pxuSe8J9FRfDV3QuKDwY/iWD31DHBKaV3QohrA1dTmwJB/3p2!Et8aLdJMR/XoOfbXKbHPDxvZr7k4xgjYKK6jkXlUnuULqdm9S5xHbQ3X3Cnr4IIbOIquZOvEHfg=
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 18:13 UTC

On 8/17/2022 1:09 PM, Mr Flibble wrote:
> On Wed, 17 Aug 2022 13:05:33 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/17/2022 12:53 PM, Mr Flibble wrote:
>>> On Wed, 17 Aug 2022 12:44:17 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 8/17/2022 12:35 PM, Mr Flibble wrote:
>>>>> 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.
>>>>>
>>>>> Not when the infinite behaviour is a property of the decider
>>>>> itself as
>>>>
>>>> It superficially seems like the behavior of H(P,P) is mutual
>>>> infinite recursion until you realize the H is merely mimicking the
>>>> behavior that P specifies.
>>>
>>> FALSE. P is NOT recursive, your H is recursive, this is plainly
>>> obvious to everyone except you.
>>
>> My key unique discovery (back in 2016) was that every conventional
>> "pathological" input used to prove that the HP cannot be solved
>> specifies infinitely recursive simulation to every simulating halt
>> decider.
>
> WRONG YOU OBTUSE FUCKING FUCKTARD. I HAVE DESIGNED A SIMULATING HALT
> DECIDER THAT IS NOT INFINITELY RECURSIVE. HOW MANY MORE TIMES DO I HAVE
> TO TELL YOU THIS BEFORE IT SINKS IN?
>
> /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]

<20220817192111.00005fee@reddwarf.jmc.corp>

copy mid

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

copy link Newsgroups: comp.theory

Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx01.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: <20220817192111.00005fee@reddwarf.jmc.corp>
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@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>
<20220817183552.00003ac2@reddwarf.jmc.corp>
<KaudnSE1cOxGtWD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220817185332.000055a8@reddwarf.jmc.corp>
<dL-dnb-VKthBsGD_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220817190914.00000957@reddwarf.jmc.corp>
<5bqdnbEipbUmsmD_nZ2dnZfqlJxh4p2d@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: 268
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Wed, 17 Aug 2022 18:21:11 UTC
Date: Wed, 17 Aug 2022 19:21:11 +0100
X-Received-Bytes: 16072

by: Mr Flibble - Wed, 17 Aug 2022 18:21 UTC

On Wed, 17 Aug 2022 13:13:32 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/17/2022 1:09 PM, Mr Flibble wrote:
> > On Wed, 17 Aug 2022 13:05:33 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 8/17/2022 12:53 PM, Mr Flibble wrote:
> >>> On Wed, 17 Aug 2022 12:44:17 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 8/17/2022 12:35 PM, Mr Flibble wrote:
> >>>>> 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.
> >>>>>
> >>>>> Not when the infinite behaviour is a property of the decider
> >>>>> itself as
> >>>>
> >>>> It superficially seems like the behavior of H(P,P) is mutual
> >>>> infinite recursion until you realize the H is merely mimicking
> >>>> the behavior that P specifies.
> >>>
> >>> FALSE. P is NOT recursive, your H is recursive, this is plainly
> >>> obvious to everyone except you.
> >>
> >> My key unique discovery (back in 2016) was that every conventional
> >> "pathological" input used to prove that the HP cannot be solved
> >> specifies infinitely recursive simulation to every simulating halt
> >> decider.
> >
> > WRONG YOU OBTUSE FUCKING FUCKTARD. I HAVE DESIGNED A SIMULATING HALT
> > DECIDER THAT IS NOT INFINITELY RECURSIVE. HOW MANY MORE TIMES DO I
> > HAVE TO TELL YOU THIS BEFORE IT SINKS IN?
> >
> > /FLIBBLE
> >
>
> Yet the behavior of your "simulation" of its
> input is incorrect in that it does not correspond
> to the beahavior that P actually specifies.
>
> P does not specify that its simulation is supposed
> to be forked off into two different processes.

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]

<AaudnXo0RuTirmD_nZ2dnZfqlJzNnZ2d@giganews.com>

copy mid

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

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 18:29:19 +0000
Date: Wed, 17 Aug 2022 13:29:36 -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>
<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>
<20220817183552.00003ac2@reddwarf.jmc.corp>
<KaudnSE1cOxGtWD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220817185332.000055a8@reddwarf.jmc.corp>
<dL-dnb-VKthBsGD_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220817190914.00000957@reddwarf.jmc.corp>
<5bqdnbEipbUmsmD_nZ2dnZfqlJxh4p2d@giganews.com>
<20220817192111.00005fee@reddwarf.jmc.corp>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220817192111.00005fee@reddwarf.jmc.corp>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <AaudnXo0RuTirmD_nZ2dnZfqlJzNnZ2d@giganews.com>
Lines: 288
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-m7PqGGGKdmmcSx+9LmwVRHFaPBkvOi5Ni2ve2Rb/+6QhVbpvnJPMtsgQqavBrLzvzZoK8VTpSe1tPGb!4FwGzNxNS5fGNp2zigoTWVZ9FOzuy8WeAy+6pVdbbv0850SZ+FHV6ory1caE5FH6zjxLtjaO8h4=
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 18:29 UTC

On 8/17/2022 1:21 PM, Mr Flibble wrote:
> On Wed, 17 Aug 2022 13:13:32 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/17/2022 1:09 PM, Mr Flibble wrote:
>>> On Wed, 17 Aug 2022 13:05:33 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 8/17/2022 12:53 PM, Mr Flibble wrote:
>>>>> On Wed, 17 Aug 2022 12:44:17 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 8/17/2022 12:35 PM, Mr Flibble wrote:
>>>>>>> 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.
>>>>>>>
>>>>>>> Not when the infinite behaviour is a property of the decider
>>>>>>> itself as
>>>>>>
>>>>>> It superficially seems like the behavior of H(P,P) is mutual
>>>>>> infinite recursion until you realize the H is merely mimicking
>>>>>> the behavior that P specifies.
>>>>>
>>>>> FALSE. P is NOT recursive, your H is recursive, this is plainly
>>>>> obvious to everyone except you.
>>>>
>>>> My key unique discovery (back in 2016) was that every conventional
>>>> "pathological" input used to prove that the HP cannot be solved
>>>> specifies infinitely recursive simulation to every simulating halt
>>>> decider.
>>>
>>> WRONG YOU OBTUSE FUCKING FUCKTARD. I HAVE DESIGNED A SIMULATING HALT
>>> DECIDER THAT IS NOT INFINITELY RECURSIVE. HOW MANY MORE TIMES DO I
>>> HAVE TO TELL YOU THIS BEFORE IT SINKS IN?
>>>
>>> /FLIBBLE
>>>
>>
>> Yet the behavior of your "simulation" of its
>> input is incorrect in that it does not correspond
>> to the beahavior that P actually specifies.
>>
>> P does not specify that its simulation is supposed
>> to be forked off into two different processes.
>
> P doesn't "have a simulation", a crucial point you keep missing, P
> doesn't care what kind of decider H is. Also my SHD does not fork off
> into "two different processes", the *simulation* is forked and P is
> totally unaware that that has happened, which IMO is a perfectly legit,
> original approach to the problem.
>
> /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]

<20220817193526.00003e70@reddwarf.jmc.corp>

copy mid

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

copy link Newsgroups: comp.theory

Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!peer03.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx05.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: <20220817193526.00003e70@reddwarf.jmc.corp>
References: <VUmdneqWu_jdjGT_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>
<20220817183552.00003ac2@reddwarf.jmc.corp>
<KaudnSE1cOxGtWD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220817185332.000055a8@reddwarf.jmc.corp>
<dL-dnb-VKthBsGD_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220817190914.00000957@reddwarf.jmc.corp>
<5bqdnbEipbUmsmD_nZ2dnZfqlJxh4p2d@giganews.com>
<20220817192111.00005fee@reddwarf.jmc.corp>
<AaudnXo0RuTirmD_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: 300
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Wed, 17 Aug 2022 18:35:26 UTC
Date: Wed, 17 Aug 2022 19:35:26 +0100
X-Received-Bytes: 17769

by: Mr Flibble - Wed, 17 Aug 2022 18:35 UTC

On Wed, 17 Aug 2022 13:29:36 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/17/2022 1:21 PM, Mr Flibble wrote:
> > On Wed, 17 Aug 2022 13:13:32 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 8/17/2022 1:09 PM, Mr Flibble wrote:
> >>> On Wed, 17 Aug 2022 13:05:33 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 8/17/2022 12:53 PM, Mr Flibble wrote:
> >>>>> On Wed, 17 Aug 2022 12:44:17 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 8/17/2022 12:35 PM, Mr Flibble wrote:
> >>>>>>> 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.
> >>>>>>>
> >>>>>>> Not when the infinite behaviour is a property of the decider
> >>>>>>> itself as
> >>>>>>
> >>>>>> It superficially seems like the behavior of H(P,P) is mutual
> >>>>>> infinite recursion until you realize the H is merely mimicking
> >>>>>> the behavior that P specifies.
> >>>>>
> >>>>> FALSE. P is NOT recursive, your H is recursive, this is plainly
> >>>>> obvious to everyone except you.
> >>>>
> >>>> My key unique discovery (back in 2016) was that every
> >>>> conventional "pathological" input used to prove that the HP
> >>>> cannot be solved specifies infinitely recursive simulation to
> >>>> every simulating halt decider.
> >>>
> >>> WRONG YOU OBTUSE FUCKING FUCKTARD. I HAVE DESIGNED A SIMULATING
> >>> HALT DECIDER THAT IS NOT INFINITELY RECURSIVE. HOW MANY MORE
> >>> TIMES DO I HAVE TO TELL YOU THIS BEFORE IT SINKS IN?
> >>>
> >>> /FLIBBLE
> >>>
> >>
> >> Yet the behavior of your "simulation" of its
> >> input is incorrect in that it does not correspond
> >> to the beahavior that P actually specifies.
> >>
> >> P does not specify that its simulation is supposed
> >> to be forked off into two different processes.
> >
> > P doesn't "have a simulation", a crucial point you keep missing, P
> > doesn't care what kind of decider H is. Also my SHD does not fork
> > off into "two different processes", the *simulation* is forked and
> > P is totally unaware that that has happened, which IMO is a
> > perfectly legit, original approach to the problem.
> >
> > /Flibble
> >
>
> Yet you cannot even specify the code for the "if statement" that
> determines that it should do this.
>
> if (some how some way the halt decider determines that its input
> halts) report halting
> else if (some how some way the halt decider determines that its input
> does not halt)
> report non-halting
> else
> report pathological 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]

<j96dndyvDvoWq2D_nZ2dnZfqlJzNnZ2d@giganews.com>

copy mid

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

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 18:42:19 +0000
Date: Wed, 17 Aug 2022 13:42:36 -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>
<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>
<20220817183552.00003ac2@reddwarf.jmc.corp>
<KaudnSE1cOxGtWD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220817185332.000055a8@reddwarf.jmc.corp>
<dL-dnb-VKthBsGD_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220817190914.00000957@reddwarf.jmc.corp>
<5bqdnbEipbUmsmD_nZ2dnZfqlJxh4p2d@giganews.com>
<20220817192111.00005fee@reddwarf.jmc.corp>
<AaudnXo0RuTirmD_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220817193526.00003e70@reddwarf.jmc.corp>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220817193526.00003e70@reddwarf.jmc.corp>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <j96dndyvDvoWq2D_nZ2dnZfqlJzNnZ2d@giganews.com>
Lines: 333
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-vfjroY9MHgSaMy+gww3pKtKEmFP4HIhdSIRoFh5RRLx/5Ypc8NDR2BvRzAkW7/XFZKiS5NPDdpdM+l7!/hlWpmucdVls3Fh1xHGmqX+BM9E7TuyVTrthOMrgMSXhvz9akroo8MOU66snLNgEH4/ilQpskU4=
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 18:42 UTC

On 8/17/2022 1:35 PM, Mr Flibble wrote:
> On Wed, 17 Aug 2022 13:29:36 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/17/2022 1:21 PM, Mr Flibble wrote:
>>> On Wed, 17 Aug 2022 13:13:32 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 8/17/2022 1:09 PM, Mr Flibble wrote:
>>>>> On Wed, 17 Aug 2022 13:05:33 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 8/17/2022 12:53 PM, Mr Flibble wrote:
>>>>>>> On Wed, 17 Aug 2022 12:44:17 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 8/17/2022 12:35 PM, Mr Flibble wrote:
>>>>>>>>> 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.
>>>>>>>>>
>>>>>>>>> Not when the infinite behaviour is a property of the decider
>>>>>>>>> itself as
>>>>>>>>
>>>>>>>> It superficially seems like the behavior of H(P,P) is mutual
>>>>>>>> infinite recursion until you realize the H is merely mimicking
>>>>>>>> the behavior that P specifies.
>>>>>>>
>>>>>>> FALSE. P is NOT recursive, your H is recursive, this is plainly
>>>>>>> obvious to everyone except you.
>>>>>>
>>>>>> My key unique discovery (back in 2016) was that every
>>>>>> conventional "pathological" input used to prove that the HP
>>>>>> cannot be solved specifies infinitely recursive simulation to
>>>>>> every simulating halt decider.
>>>>>
>>>>> WRONG YOU OBTUSE FUCKING FUCKTARD. I HAVE DESIGNED A SIMULATING
>>>>> HALT DECIDER THAT IS NOT INFINITELY RECURSIVE. HOW MANY MORE
>>>>> TIMES DO I HAVE TO TELL YOU THIS BEFORE IT SINKS IN?
>>>>>
>>>>> /FLIBBLE
>>>>>
>>>>
>>>> Yet the behavior of your "simulation" of its
>>>> input is incorrect in that it does not correspond
>>>> to the beahavior that P actually specifies.
>>>>
>>>> P does not specify that its simulation is supposed
>>>> to be forked off into two different processes.
>>>
>>> P doesn't "have a simulation", a crucial point you keep missing, P
>>> doesn't care what kind of decider H is. Also my SHD does not fork
>>> off into "two different processes", the *simulation* is forked and
>>> P is totally unaware that that has happened, which IMO is a
>>> perfectly legit, original approach to the problem.
>>>
>>> /Flibble
>>>
>>
>> Yet you cannot even specify the code for the "if statement" that
>> determines that it should do this.
>>
>> if (some how some way the halt decider determines that its input
>> halts) report halting
>> else if (some how some way the halt decider determines that its input
>> does not halt)
>> report non-halting
>> else
>> report pathological input
>
> I only need to specify code if I was to actually implement it.

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]

<20220817194626.00002a51@reddwarf.jmc.corp>

copy mid

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

copy link Newsgroups: comp.theory

Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx05.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: <20220817194626.00002a51@reddwarf.jmc.corp>
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@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>
<20220817183552.00003ac2@reddwarf.jmc.corp>
<KaudnSE1cOxGtWD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220817185332.000055a8@reddwarf.jmc.corp>
<dL-dnb-VKthBsGD_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220817190914.00000957@reddwarf.jmc.corp>
<5bqdnbEipbUmsmD_nZ2dnZfqlJxh4p2d@giganews.com>
<20220817192111.00005fee@reddwarf.jmc.corp>
<AaudnXo0RuTirmD_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220817193526.00003e70@reddwarf.jmc.corp>
<j96dndyvDvoWq2D_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: 328
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Wed, 17 Aug 2022 18:46:26 UTC
Date: Wed, 17 Aug 2022 19:46:26 +0100
X-Received-Bytes: 19352

by: Mr Flibble - Wed, 17 Aug 2022 18:46 UTC

On Wed, 17 Aug 2022 13:42:36 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/17/2022 1:35 PM, Mr Flibble wrote:
> > On Wed, 17 Aug 2022 13:29:36 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 8/17/2022 1:21 PM, Mr Flibble wrote:
> >>> On Wed, 17 Aug 2022 13:13:32 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 8/17/2022 1:09 PM, Mr Flibble wrote:
> >>>>> On Wed, 17 Aug 2022 13:05:33 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 8/17/2022 12:53 PM, Mr Flibble wrote:
> >>>>>>> On Wed, 17 Aug 2022 12:44:17 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 8/17/2022 12:35 PM, Mr Flibble wrote:
> >>>>>>>>> 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.
> >>>>>>>>>
> >>>>>>>>> Not when the infinite behaviour is a property of the decider
> >>>>>>>>> itself as
> >>>>>>>>
> >>>>>>>> It superficially seems like the behavior of H(P,P) is mutual
> >>>>>>>> infinite recursion until you realize the H is merely
> >>>>>>>> mimicking the behavior that P specifies.
> >>>>>>>
> >>>>>>> FALSE. P is NOT recursive, your H is recursive, this is
> >>>>>>> plainly obvious to everyone except you.
> >>>>>>
> >>>>>> My key unique discovery (back in 2016) was that every
> >>>>>> conventional "pathological" input used to prove that the HP
> >>>>>> cannot be solved specifies infinitely recursive simulation to
> >>>>>> every simulating halt decider.
> >>>>>
> >>>>> WRONG YOU OBTUSE FUCKING FUCKTARD. I HAVE DESIGNED A SIMULATING
> >>>>> HALT DECIDER THAT IS NOT INFINITELY RECURSIVE. HOW MANY MORE
> >>>>> TIMES DO I HAVE TO TELL YOU THIS BEFORE IT SINKS IN?
> >>>>>
> >>>>> /FLIBBLE
> >>>>>
> >>>>
> >>>> Yet the behavior of your "simulation" of its
> >>>> input is incorrect in that it does not correspond
> >>>> to the beahavior that P actually specifies.
> >>>>
> >>>> P does not specify that its simulation is supposed
> >>>> to be forked off into two different processes.
> >>>
> >>> P doesn't "have a simulation", a crucial point you keep missing, P
> >>> doesn't care what kind of decider H is. Also my SHD does not fork
> >>> off into "two different processes", the *simulation* is forked and
> >>> P is totally unaware that that has happened, which IMO is a
> >>> perfectly legit, original approach to the problem.
> >>>
> >>> /Flibble
> >>>
> >>
> >> Yet you cannot even specify the code for the "if statement" that
> >> determines that it should do this.
> >>
> >> if (some how some way the halt decider determines that its input
> >> halts) report halting
> >> else if (some how some way the halt decider determines that its
> >> input does not halt)
> >> report non-halting
> >> else
> >> report pathological input
> >
> > I only need to specify code if I was to actually implement it.
>
> What you have done is the same as if I said:
> "I have a cure for cancer" where my "cure" is:
> (1) Find a cure for cancer
> (2) Then we have a cure for cancer.

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

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

copy mid

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

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 19:57:06 +0100
Organization: A noiseless patient Spider
Lines: 31
Message-ID: <87o7wi4s1p.fsf@bsb.me.uk>
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>
<87wnb73wrl.fsf@bsb.me.uk>
<21aaa5c2-cb81-43a6-84e4-7a35640a39fdn@googlegroups.com>
MIME-Version: 1.0
Content-Type: text/plain
Injection-Info: reader01.eternal-september.org; posting-host="e9eba11d11c44ea8c13e95dfb596e75b";
logging-data="557664"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19EZYzn5eQ6Ty+pGYvA9OopWBWC3nvBNxU="
User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/27.1 (gnu/linux)
Cancel-Lock: sha1:PDg8kyogRNIp3RS3qwMfkIiPicw=
sha1:vMzSBDvNKeWNhi8uiOzt8C9pnO8=
X-BSB-Auth: 1.bc195341c2912c2c7c50.20220817195706BST.87o7wi4s1p.fsf@bsb.me.uk

by: Ben Bacarisse - Wed, 17 Aug 2022 18:57 UTC

Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:

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

That's why I don't used the word in that that way, but it helps to know
that some people do.

--
Ben.

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

<43410226-6f59-4da9-9e37-9b4de32d0245n@googlegroups.com>

copy mid

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

copy link Newsgroups: comp.theory

X-Received: by 2002:a05:622a:14cd:b0:344:6cfa:42f9 with SMTP id u13-20020a05622a14cd00b003446cfa42f9mr621qtx.147.1660769017292;
Wed, 17 Aug 2022 13:43:37 -0700 (PDT)
X-Received: by 2002:a81:bb41:0:b0:328:fd1b:5713 with SMTP id
a1-20020a81bb41000000b00328fd1b5713mr23363992ywl.238.1660768962308; Wed, 17
Aug 2022 13:42:42 -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 13:42:42 -0700 (PDT)
In-Reply-To: <87wnb73wrl.fsf@bsb.me.uk>
Injection-Info: google-groups.googlegroups.com; posting-host=47.208.151.23; posting-account=7Xc2EwkAAABXMcQfERYamr3b-64IkBws
NNTP-Posting-Host: 47.208.151.23
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: <43410226-6f59-4da9-9e37-9b4de32d0245n@googlegroups.com>
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
From: dkleine...@gmail.com (dklei...@gmail.com)
Injection-Date: Wed, 17 Aug 2022 20:42:42 +0000
Content-Type: text/plain; charset="UTF-8"
Lines: 13

by: dklei...@gmail.com - Wed, 17 Aug 2022 20:42 UTC

On Wednesday, August 17, 2022 at 5:00:34 AM UTC-7, 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:

> >> > 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?
>
I goofed up. I meant that H always returns a value and therefore
always halts. That it is a Turing Machine is implicit.

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

<JJmcndzTi54Iy2D_nZ2dnZfqlJ_NnZ2d@giganews.com>

copy mid

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

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 20:59:01 +0000
Date: Wed, 17 Aug 2022 15:59:23 -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>
<87wnb73wrl.fsf@bsb.me.uk>
<43410226-6f59-4da9-9e37-9b4de32d0245n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <43410226-6f59-4da9-9e37-9b4de32d0245n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <JJmcndzTi54Iy2D_nZ2dnZfqlJ_NnZ2d@giganews.com>
Lines: 33
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-l8YIrBQCwMj0riFO2gFHo+NKVBQNbOFeW6IdhQU2FgG/9ySlAAmiPMenXUHmZblcr1j9BXDn723LNU+!5UBiS4tezQjnEePzlfk0E+N0hIY6/CLcz/H3/ddvJ2+RTfOmlZYAZzzcXAhnJATICrPhN9NJjHM=
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 20:59 UTC

On 8/17/2022 3:42 PM, dklei...@gmail.com wrote:
> On Wednesday, August 17, 2022 at 5:00:34 AM UTC-7, 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:
>
>>>>> 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?
>>
> I goofed up. I meant that H always returns a value and therefore
> always halts. That it is a Turing Machine is implicit.

I specify that H is a C function, when you say it is a TM that is the
same as saying that cats are dogs.

Whether or not this C function is equivalent to a TM is a whole
different conversation, I am (at this point) only saying that H(P,P)
does correctly determine that its first argument specifies a sequence of
instructions that never halt.

ONLY after mutual understanding is achieved on this point can we move on
to the different subject of whether or not H is equivalent to a TM.

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

<cbd33524-9b59-473c-a878-f1cdadcea04an@googlegroups.com>

copy mid

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

copy link Newsgroups: comp.theory

X-Received: by 2002:a37:8606:0:b0:6b8:e6d7:af09 with SMTP id i6-20020a378606000000b006b8e6d7af09mr78499qkd.416.1660773347442;
Wed, 17 Aug 2022 14:55:47 -0700 (PDT)
X-Received: by 2002:a0d:d610:0:b0:335:e884:e528 with SMTP id
y16-20020a0dd610000000b00335e884e528mr170117ywd.494.1660773347247; Wed, 17
Aug 2022 14:55:47 -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 14:55:47 -0700 (PDT)
In-Reply-To: <JJmcndzTi54Iy2D_nZ2dnZfqlJ_NnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=47.208.151.23; posting-account=7Xc2EwkAAABXMcQfERYamr3b-64IkBws
NNTP-Posting-Host: 47.208.151.23
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>
<87wnb73wrl.fsf@bsb.me.uk> <43410226-6f59-4da9-9e37-9b4de32d0245n@googlegroups.com>
<JJmcndzTi54Iy2D_nZ2dnZfqlJ_NnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <cbd33524-9b59-473c-a878-f1cdadcea04an@googlegroups.com>
Subject: Re: Here is what a computer scientist that has been published in CACM
said about my work [competence?]
From: dkleine...@gmail.com (dklei...@gmail.com)
Injection-Date: Wed, 17 Aug 2022 21:55:47 +0000
Content-Type: text/plain; charset="UTF-8"
X-Received-Bytes: 4191

by: dklei...@gmail.com - Wed, 17 Aug 2022 21:55 UTC

On Wednesday, August 17, 2022 at 1:59:32 PM UTC-7, olcott wrote:
> On 8/17/2022 3:42 PM, dklei...@gmail.com wrote:
> > On Wednesday, August 17, 2022 at 5:00:34 AM UTC-7, 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:
> >
> >>>>> 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?
> >>
> > I goofed up. I meant that H always returns a value and therefore
> > always halts. That it is a Turing Machine is implicit.
> I specify that H is a C function, when you say it is a TM that is the
> same as saying that cats are dogs.
>
> Whether or not this C function is equivalent to a TM is a whole
> different conversation, I am (at this point) only saying that H(P,P)
> does correctly determine that its first argument specifies a sequence of
> instructions that never halt.
>
> ONLY after mutual understanding is achieved on this point can we move on
> to the different subject of whether or not H is equivalent to a TM.
>
We are concerned with a classical procedure - a halting decider. A
halting decider is a halting Turing Machine that, given an encoding of some
Turing Machine on its initial tape returns a "true" if the encoded
machine, when run, will halt and a "false" otherwise.

The only reason for interest in any C program is that we are going
to assume the the C program is equivalent to the halting decider.
One of the problems with this discussion has been too many things
are all called H.

Incidentally it seem to be a theorem that for any N there are two
different Turing Machines one of which halts and the other does
not where the first N steps when run are identical. This, in a way,
destroys the idea of a simulating halt decider.

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

<6tmdnZGGspgr9WD_nZ2dnZfqlJ_NnZ2d@giganews.com>

copy mid

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

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!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 22:16:22 +0000
Date: Wed, 17 Aug 2022 17:16:44 -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>
<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>
<43410226-6f59-4da9-9e37-9b4de32d0245n@googlegroups.com>
<JJmcndzTi54Iy2D_nZ2dnZfqlJ_NnZ2d@giganews.com>
<cbd33524-9b59-473c-a878-f1cdadcea04an@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <cbd33524-9b59-473c-a878-f1cdadcea04an@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <6tmdnZGGspgr9WD_nZ2dnZfqlJ_NnZ2d@giganews.com>
Lines: 68
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-y3Z5CJJIbkFAZqbC51J5jM05poCVt/arTfSg+cX4ejjjoyH7SVPrtWeuzUErQShM8JrdmbC7ay6mnrM!SHZaxTZIXUmuJiApfZPVaC2H87b844Mj2QrdkQVhMEwNxdqEzpBzNcgUfiSLdyTWcx7iFFPdY+o=
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: 5164

by: olcott - Wed, 17 Aug 2022 22:16 UTC

On 8/17/2022 4:55 PM, dklei...@gmail.com wrote:
> On Wednesday, August 17, 2022 at 1:59:32 PM UTC-7, olcott wrote:
>> On 8/17/2022 3:42 PM, dklei...@gmail.com wrote:
>>> On Wednesday, August 17, 2022 at 5:00:34 AM UTC-7, 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:
>>>
>>>>>>> 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?
>>>>
>>> I goofed up. I meant that H always returns a value and therefore
>>> always halts. That it is a Turing Machine is implicit.
>> I specify that H is a C function, when you say it is a TM that is the
>> same as saying that cats are dogs.
>>
>> Whether or not this C function is equivalent to a TM is a whole
>> different conversation, I am (at this point) only saying that H(P,P)
>> does correctly determine that its first argument specifies a sequence of
>> instructions that never halt.
>>
>> ONLY after mutual understanding is achieved on this point can we move on
>> to the different subject of whether or not H is equivalent to a TM.
>>
> We are concerned with a classical procedure - a halting decider.

You can't possibly understand what I am saying UNLESS YOU GO THROUGH ALL
THE STEPS. If you are unwilling to do this then I cannot afford wasting
any more time talking to you.

I WILL GET TO THE CLASSIC PROOF ONLY AFTER WE HAVE GONE THROUGH ALL OF
MY STEPS.

> A
> halting decider is a halting Turing Machine that, given an encoding of some
> Turing Machine on its initial tape returns a "true" if the encoded
> machine, when run, will halt and a "false" otherwise.
>
> The only reason for interest in any C program is that we are going
> to assume the the C program is equivalent to the halting decider.
> One of the problems with this discussion has been too many things
> are all called H.
>

THE HALTING PROBLEM PROOFS HAVE MORE THAN ONE MISTAKE.

IT IS UTTERLY IMPOSSIBLE TO SEE THIS MISTAKE UNTIL IT IS COMPARED AND
CONTRASTED WITH THE CORRECT WAY OF DOING IT.

THE CORRECT WAY OF DOING IT IS MOST EASILY SEEN BY ATTAINING A 100%
PERFECTLY COMPLETE UNDERSTANDING OF MY C FUNCTIONS.

> Incidentally it seem to be a theorem that for any N there are two
> different Turing Machines one of which halts and the other does
> not where the first N steps when run are identical. This, in a way,
> destroys the idea of a simulating halt decider.

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

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

copy mid

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

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 23:28:04 +0100
Organization: A noiseless patient Spider
Lines: 61
Message-ID: <87a6824ia3.fsf@bsb.me.uk>
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@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>
<43410226-6f59-4da9-9e37-9b4de32d0245n@googlegroups.com>
<JJmcndzTi54Iy2D_nZ2dnZfqlJ_NnZ2d@giganews.com>
<cbd33524-9b59-473c-a878-f1cdadcea04an@googlegroups.com>
MIME-Version: 1.0
Content-Type: text/plain
Injection-Info: reader01.eternal-september.org; posting-host="a54155419a9e24f9957ac47df066e951";
logging-data="631244"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/b2Wj3Qj70EvefRw5fj0feqC6+9gUAs7Y="
User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/27.1 (gnu/linux)
Cancel-Lock: sha1:UgyGr7gBvl4Ub47FyzOXykskweQ=
sha1:tSTNaGNRBwGjVkqOx3u/z9C5HkM=
X-BSB-Auth: 1.f82b5257bcb39bd77d16.20220817232804BST.87a6824ia3.fsf@bsb.me.uk

by: Ben Bacarisse - Wed, 17 Aug 2022 22:28 UTC

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

> On Wednesday, August 17, 2022 at 1:59:32 PM UTC-7, olcott wrote:
>> On 8/17/2022 3:42 PM, dklei...@gmail.com wrote:
>> > On Wednesday, August 17, 2022 at 5:00:34 AM UTC-7, 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:
>> >
>> >>>>> 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?
>> >>
>> > I goofed up. I meant that H always returns a value and therefore
>> > always halts. That it is a Turing Machine is implicit.
>> I specify that H is a C function, when you say it is a TM that is the
>> same as saying that cats are dogs.
>>
>> Whether or not this C function is equivalent to a TM is a whole
>> different conversation, I am (at this point) only saying that H(P,P)
>> does correctly determine that its first argument specifies a sequence of
>> instructions that never halt.
>>
>> ONLY after mutual understanding is achieved on this point can we move on
>> to the different subject of whether or not H is equivalent to a TM.
>>
> We are concerned with a classical procedure - a halting decider. A
> halting decider is a halting Turing Machine that, given an encoding of some
> Turing Machine on its initial tape returns a "true" if the encoded
> machine, when run, will halt and a "false" otherwise.
>
> The only reason for interest in any C program is that we are going
> to assume the the C program is equivalent to the halting decider.
> One of the problems with this discussion has been too many things
> are all called H.
>
> Incidentally it seem to be a theorem that for any N there are two
> different Turing Machines one of which halts and the other does
> not where the first N steps when run are identical. This, in a way,
> destroys the idea of a simulating halt decider.

Well, yes (trivially so). But then there is a theorem that states that
there are no halt deciders, simulating or otherwise, and /that/ theorem
has not had any impact on POs in the last 18 years.

The trouble is that theorems run off PO like water off a duck's back.
He thinks of them like arguments made in court, and he see himself as a
mathematical Perry Mason presenting a dramatic "Aha!" moment. I once
asked him if there was any theorem of which he was so sure that he could
not imagine any sane person rejecting it, and he just kept ducking the
question.

Anyway, good luck. Maybe this remark will be the one that, after 18
years, makes PO slap his forehead go "gosh, you're right; what /was/
I thinking!".

--
Ben.

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

<p5SdnWWvMvTK62D_nZ2dnZfqlJzNnZ2d@giganews.com>

copy mid

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

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 23:14:31 +0000
Date: Wed, 17 Aug 2022 18:14:48 -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>
<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>
<43410226-6f59-4da9-9e37-9b4de32d0245n@googlegroups.com>
<JJmcndzTi54Iy2D_nZ2dnZfqlJ_NnZ2d@giganews.com>
<cbd33524-9b59-473c-a878-f1cdadcea04an@googlegroups.com>
<87a6824ia3.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <87a6824ia3.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <p5SdnWWvMvTK62D_nZ2dnZfqlJzNnZ2d@giganews.com>
Lines: 72
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-bmoQRBPjC53hU3KZeIcNOH9a6BvYTwSqDv5tkmNFMTa2c8UFgl+0vDjdMeanIpxxccqoUP63ouL0atH!zjvbjzdROhasNzWFvRTAny08HC76u2EEZUseQzvAjmQtHClTFJQUvDU94PQM/DaOeybfNxB1p+s=
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 23:14 UTC

On 8/17/2022 5:28 PM, Ben Bacarisse wrote:
> "dklei...@gmail.com" <dkleinecke@gmail.com> writes:
>
>> On Wednesday, August 17, 2022 at 1:59:32 PM UTC-7, olcott wrote:
>>> On 8/17/2022 3:42 PM, dklei...@gmail.com wrote:
>>>> On Wednesday, August 17, 2022 at 5:00:34 AM UTC-7, 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:
>>>>
>>>>>>>> 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?
>>>>>
>>>> I goofed up. I meant that H always returns a value and therefore
>>>> always halts. That it is a Turing Machine is implicit.
>>> I specify that H is a C function, when you say it is a TM that is the
>>> same as saying that cats are dogs.
>>>
>>> Whether or not this C function is equivalent to a TM is a whole
>>> different conversation, I am (at this point) only saying that H(P,P)
>>> does correctly determine that its first argument specifies a sequence of
>>> instructions that never halt.
>>>
>>> ONLY after mutual understanding is achieved on this point can we move on
>>> to the different subject of whether or not H is equivalent to a TM.
>>>
>> We are concerned with a classical procedure - a halting decider. A
>> halting decider is a halting Turing Machine that, given an encoding of some
>> Turing Machine on its initial tape returns a "true" if the encoded
>> machine, when run, will halt and a "false" otherwise.
>>
>> The only reason for interest in any C program is that we are going
>> to assume the the C program is equivalent to the halting decider.
>> One of the problems with this discussion has been too many things
>> are all called H.
>>
>> Incidentally it seem to be a theorem that for any N there are two
>> different Turing Machines one of which halts and the other does
>> not where the first N steps when run are identical. This, in a way,
>> destroys the idea of a simulating halt decider.
>
> Well, yes (trivially so). But then there is a theorem that states that
> there are no halt deciders, simulating or otherwise, and /that/ theorem
> has not had any impact on POs in the last 18 years.
>
> The trouble is that theorems run off PO like water off a duck's back.
> He thinks of them like arguments made in court, and he see himself as a
> mathematical Perry Mason presenting a dramatic "Aha!" moment. I once
> asked him if there was any theorem of which he was so sure that he could
> not imagine any sane person rejecting it, and he just kept ducking the
> question.
>
> Anyway, good luck. Maybe this remark will be the one that, after 18
> years, makes PO slap his forehead go "gosh, you're right; what /was/
> I thinking!".
>

The problem seems to be that you lack the technical competence to review
my work in that after I published the source-code you still thought it
was a ruse until Mike corrected you and told you that my code does
behave as I have claimed.

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

<5DfLK.72803$kY1.13796@fx06.iad>

copy mid

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

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!fx06.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>
<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>
<7e6dncpnS5v8a2H_nZ2dnZfqlJzNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <7e6dncpnS5v8a2H_nZ2dnZfqlJzNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 43
Message-ID: <5DfLK.72803$kY1.13796@fx06.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 20:22:25 -0400
X-Received-Bytes: 3259

by: Richard Damon - Thu, 18 Aug 2022 00:22 UTC

On 8/17/22 10:08 AM, olcott wrote:
> 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.

No, it isn't, because it is not predicting that something WILL Happen,
because it is considering a not just "Hypothetical" case, but a case
that specifically can not occur, since it looks at an H that is
different then the H that actually is.
>
>> 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.

Right, so it is making a prediction about a fictitious event.

>
>> A conterfactual statement does not prove or refute
>> anything.
>>
>> Mikko
>>
>
> It only seems counter-factual because of your errors.
>

No, it is counter-factual because it is "predicting" the behavior of
something that isn't what is actually there.

That is like what color were Napoleon's Shoes that used to walk on Mars.

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

<_FfLK.72804$kY1.40321@fx06.iad>

copy mid

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

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!fx06.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 [stupid]
Content-Language: en-US
Newsgroups: comp.theory
References: <VUmdneqWu_jdjGT_nZ2dnZfqlJ_NnZ2d@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>
<20220817183552.00003ac2@reddwarf.jmc.corp>
<KaudnSE1cOxGtWD_nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220817185332.000055a8@reddwarf.jmc.corp>
<dL-dnb-VKthBsGD_nZ2dnZfqlJzNnZ2d@giganews.com>
<20220817190914.00000957@reddwarf.jmc.corp>
<5bqdnbEipbUmsmD_nZ2dnZfqlJxh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <5bqdnbEipbUmsmD_nZ2dnZfqlJxh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 15
Message-ID: <_FfLK.72804$kY1.40321@fx06.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 20:25:29 -0400
X-Received-Bytes: 2391

by: Richard Damon - Thu, 18 Aug 2022 00:25 UTC

On 8/17/22 2:13 PM, olcott wrote:
>
> Yet the behavior of your "simulation" of its
> input is incorrect in that it does not correspond
> to the beahavior that P actually specifies.
>
> P does not specify that its simulation is supposed
> to be forked off into two different processes.

And neither does yours.

Note, His H doesn't simulate a forking, it forks to try two options.

Note, it doesn't need to ACTUALLY fork, it can sequentially try the two
options (assuming it can decide the results of both cases in finite time).

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

<y0gLK.793819$J0r9.671384@fx11.iad>

copy mid

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

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!fx11.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.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>
<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>
<ENOdndtEMevGmWD_nZ2dnZfqlJzNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <ENOdndtEMevGmWD_nZ2dnZfqlJzNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 296
Message-ID: <y0gLK.793819$J0r9.671384@fx11.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 17 Aug 2022 20:49:34 -0400
X-Received-Bytes: 12601

by: Richard Damon - Thu, 18 Aug 2022 00:49 UTC

On 8/17/22 11:08 AM, olcott wrote:
> 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.

Nope, you have shown that it halts.

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

Yes it does.

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

And because of that, P(P), which is what the input of H(P,P) is asking
about, does Halt BECAUSE H(P,P), as you have defined it, returns 0.

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

How do you get that?

The teacher give a test.

Each question has a right answer.

The answers are compared to the correct answer and graded.

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

Except that BECAUSE H(P,P) aborts its simulation and return 0, means
that the correct and complete simulation of that input (Which H didn't
do) will reach the final state and 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.

It is? From where. Remember Axioms are the ACCEPTED agreed upon truths
that a system is built on.

Please provide your reference or you are showing that you are just a liar.

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

But that ISN'T the actual definition of the Halting Problem, the ACTUAL
definition of the Halting Problem is based on the behavior of the
machine the input represents (which in this case is P(P) ) and the
replacement with a simulation is only allowed because it is defined to
agree with that.

If you use that alternate view, the definition of

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

So, you are agreeing that the thing that H needs to be considering is
the FULL Program P, and not just the C 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.

WHY>

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

Except that ISN'T the behavior that your H generates. since the H0
simulation will abort its simulation of H1^ when it reaches the point of
having H1 simulate <H2^> <H3^>

THe H0^ will Halt.

Note "unless their simulation is aborted" is a meaningless phrase,
because since it either WILL abort (as described above) and that shows
that the input is Halting, or it WILL NOT abort, and thus no H ever
gives an answer so it fails to be a decider.

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

WRONG. THE CORRECT SIMULATION of the input will.

It doesn't matter that the partial simulation done by H didn't

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

No, you are failing to note that while there is a distinction, there
also is in this case a direct equivalence.

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

But both must behave the same, so it doesn't matter.

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

Nope, just shows that you don't understand what you are talking about.

The UTM uses the whole tape.

UTM <H^> <H^> will Halt, which shows that H^ <H^> is a Halting
computaiton and thus H <H^> <H^> needs to accept.

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

And you have definied that you H will then eventially, in finite time,
reject the input and go to Qn and H^ will Halt.

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

Actually, it does have an effect on the results, but not worth actually
arguing since it is clear that it is over you head.

My point is that when you try to make your H inot a Turing Machine, you
will find that it doesn't work.

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

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

<AN-dnZxwirJvDGD_nZ2dnZfqlJxh4p2d@giganews.com>

copy mid

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

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: Thu, 18 Aug 2022 01:12:18 +0000
Date: Wed, 17 Aug 2022 20:12:34 -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>
<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>
<ENOdndtEMevGmWD_nZ2dnZfqlJzNnZ2d@giganews.com>
<y0gLK.793819$J0r9.671384@fx11.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <y0gLK.793819$J0r9.671384@fx11.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <AN-dnZxwirJvDGD_nZ2dnZfqlJxh4p2d@giganews.com>
Lines: 48
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-pkrv3eH8PVCo0xrFcPgVJviSBCC2MgEiaMLbVMoDk5QxJfKS8H+CmVK6/lQkT6kBdIhfw3W8v3FrwID!7QOafk4+SpOKdQojxygTa0lw8L4dgX/nJsPjNVTi7z9K48TvjKDxChjfWvBm1uPpBTtrOR5AkeA=
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: 4062

by: olcott - Thu, 18 Aug 2022 01:12 UTC

On 8/17/2022 7:49 PM, Richard Damon wrote:
> On 8/17/22 11:08 AM, olcott wrote:
>> 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.
>
> Nope, you have shown that it halts.
I have shown that the input simulated by H(P,P) reaches the "return"
instruction (final state of this input?

computation that halts … the Turing machine will halt whenever it enters
a final state. (Linz:1990:234)

"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?]

<EIgLK.927006$JVi.159216@fx17.iad>

copy mid

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

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!fx17.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>
<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>
<ENOdndtEMevGmWD_nZ2dnZfqlJzNnZ2d@giganews.com>
<y0gLK.793819$J0r9.671384@fx11.iad>
<AN-dnZxwirJvDGD_nZ2dnZfqlJxh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <AN-dnZxwirJvDGD_nZ2dnZfqlJxh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 62
Message-ID: <EIgLK.927006$JVi.159216@fx17.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 21:36:35 -0400
X-Received-Bytes: 4314

by: Richard Damon - Thu, 18 Aug 2022 01:36 UTC

On 8/17/22 9:12 PM, olcott wrote:
> On 8/17/2022 7:49 PM, Richard Damon wrote:
>> On 8/17/22 11:08 AM, olcott wrote:
>>> 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.
>>
>> Nope, you have shown that it halts.
> I have shown that the input simulated by H(P,P) reaches the "return"
> instruction (final state of this input?
>
> computation that halts … the Turing machine will halt whenever it enters
> a final state. (Linz:1990:234)
>
>
>

You have shown that the CORRECT (and complete) simulation of the input
to H(P,P) will Halt.

Not by H, but the correct and complete simulation of a given finite
string input is ALWAYS the same.

The key is your H doesn't do a correct and complete simulation.

Note, Read your definition of A Computation that Halts, what matters is
the Turing Machine that does the Computaiton. That is the P of the input
H(P,P), so the definition refers to the ACTUAL P(P).

The simulation of the input by H doesn't apply, as it isn't the machine.

Unless you are using it to say that it is H that Halts, but the key is
that if H(P,p) Halts with the answer 0, then P(P) Halts too, so the
answer H gave was wrong.

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

<HfCdnUCy77LtPWD_nZ2dnZfqlJzNnZ2d@giganews.com>

copy mid

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

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: Thu, 18 Aug 2022 02:14:08 +0000
Date: Wed, 17 Aug 2022 21:14: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>
<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>
<ENOdndtEMevGmWD_nZ2dnZfqlJzNnZ2d@giganews.com>
<y0gLK.793819$J0r9.671384@fx11.iad>
<AN-dnZxwirJvDGD_nZ2dnZfqlJxh4p2d@giganews.com>
<EIgLK.927006$JVi.159216@fx17.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <EIgLK.927006$JVi.159216@fx17.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <HfCdnUCy77LtPWD_nZ2dnZfqlJzNnZ2d@giganews.com>
Lines: 63
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-tBOa4tVQjKh8dx1U5nvFk+WoI1e4jV9T9jeBj4mvFy5Jv0tFDztD56nq8ICJu6fTSkBOdmyFkL4e0xq!Kn4xg/YPeNhruWRQh1vN/cq71PsvZybEnQbLE22Xh5yOsW260CY88GC9y0hOEQ4NUI+8ibQLkP8=
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 - Thu, 18 Aug 2022 02:14 UTC

On 8/17/2022 8:36 PM, Richard Damon wrote:
> On 8/17/22 9:12 PM, olcott wrote:
>> On 8/17/2022 7:49 PM, Richard Damon wrote:
>>> On 8/17/22 11:08 AM, olcott wrote:
>>>> 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.
>>>
>>> Nope, you have shown that it halts.
>> I have shown that the input simulated by H(P,P) reaches the "return"
>> instruction (final state of this input?
>>
>> computation that halts … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>>
>>
>>
>
> You have shown that the CORRECT (and complete) simulation of the input
> to H(P,P) will Halt.
>
I have shown that the CORRECT (and complete) simulation of the input
to H(P,P) *BY H* will Halt
*MEANING THE THE SIMULATED INPUT REACHES ITS "return" instruction*
(final state)

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

Pages:1 2 3 4 5 678 9 10

server_pubkey.txt

rocksolid light 0.9.8
clearnet tor