Path: ...!news.misty.com!weretis.net!feeder9.news.weretis.net!i2pn.org!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory
Subject: Re: Hypothetical IMpossibilities -- I reread this again more
 carefully
Date: Sun, 21 Jul 2024 13:52:53 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <f45b6138404f0554773407a9171f5eea6e8ca462@i2pn2.org>
References: <v7gl30$3j9fi$1@dont-email.me> <v7h1fl$3lcvq$3@dont-email.me>
 <v7h224$3li66$3@dont-email.me>
 <e975eef57ba6d3d4cc790818c05b7165443f7ce4@i2pn2.org>
 <v7h5b2$3m6kq$2@dont-email.me>
 <73e4850d3b48903cf85b2967ba713aced98caf96@i2pn2.org>
 <v7h9on$3muu0$1@dont-email.me>
 <09536cf44fc4c3d14b37641cf8fdc9e8a8c24580@i2pn2.org>
 <v7hept$3o0be$1@dont-email.me>
 <97884acd35091ddd67bda892c7a3dd28e188f760@i2pn2.org>
 <v7hftt$3o7r5$1@dont-email.me>
 <f74209ef7d87b6f7891e4a2b89cc18bfe7233810@i2pn2.org>
 <v7hkb2$3otgn$1@dont-email.me>
 <1c5729ae6d0a7bca84d24eec9f85bf30de70e3d9@i2pn2.org>
 <v7hnu6$3pd9s$1@dont-email.me>
 <f0dda3e0d0e85081d8ce0cdd494f5f1f8f8c89e3@i2pn2.org>
 <v7huen$3u1jc$3@dont-email.me>
 <6883b0a9674975998092c404f9eaa331ad1556b9@i2pn2.org>
 <v7i20r$3ucnd$1@dont-email.me>
 <8e0bcb6d7508f8334460e30557d444abc5356a03@i2pn2.org>
 <v7j197$3o7r$1@dont-email.me>
 <b49b352a8ccb22193a77e07032530bee26fd326f@i2pn2.org>
 <v7j6ah$3o7r$10@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Sun, 21 Jul 2024 17:52:53 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="3938152"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
Content-Language: en-US
X-Spam-Checker-Version: SpamAssassin 4.0.0
In-Reply-To: <v7j6ah$3o7r$10@dont-email.me>
Bytes: 5535
Lines: 80

On 7/21/24 10:34 AM, olcott wrote:
> On 7/21/2024 9:24 AM, joes wrote:
>> Am Sun, 21 Jul 2024 08:08:53 -0500 schrieb olcott:
>>> On 7/21/2024 6:37 AM, Richard Damon wrote:
>>>> On 7/21/24 12:15 AM, olcott wrote:
>>>>> When the simulation stops running the whole program exits to the
>>>>> operating system.
>> Yes. That doesn't mean that DDD itself would terminate.
>>
> Correct.

Which means you agree that HHH's aborting of its simuliation doesn't 
stop the behavior of DDD, but it continues until we find what it does.

> 
>>> Because (a) We know that it is a logical impossibility for any decider
>>> HHH to report on the halt status of any input that does the opposite of
>>> whatever it reports.
>>> (b) We know that a decider is not allowed to report on the behavior
>>> computation that itself is contained within. Deciders only take finite
>>> string inputs. They do not take executing processes as inputs. Thus HHH
>>> is not allowed to report on the behavior of this int main() { DDD(); }.
> 
>> That IS exactly the input.
>>
> 
> The behavior of emulated DDD after it has been aborted
> changes the behavior of the directly existed DDD.
> 

No, it doesn't CHANGE the behavior, but the fact that HHH aborts its 
simulation of its input and returns ESTABLISHES the behavior of ALL 
copies of that DDD that call it.

> When the second call of what would otherwise be infinite recursion
> is required to be aborted to prevent the infinite execution of the
> first call this proves that HHH(DDD)==0 is correct even though
> the directly executed DDD() halts.

It never WAS "otherwise infinite recursin" because this HHH ALWAYS 
ABORTED it input. You confuse the different problems in your set of 
problems with one program "changing" which doesn't actually happen.

> 
>>> Therefore we map the finite string input to HHH(DDD) to the behavior
>>> that it species on the basis of DDD correctly emulated by any pure
>>> function HHH that can possibly exist.
>> The basis is the direct behaviour.
>>
> 
> Unless you think the idea of UTMs is wrong-headed nonsense
> the behavior of DDD correctly emulated by HHH determines
> the actual behavior specified by the input to HHH(DDD).
> 

No, because the decider HHH is not a UTM. PERIOD, The only version of 
HHH that acts like a UTM is the one that never aborts its simulation, 
and that one you have shown doesn't answer and thus is not a decider.

Thus, you are showing that you don't understand what a UTM actually is, 
because you have made yourself INTENTIONALLY IGNORANT of the topic.

The ACTUAL UTM processing of the EXACT input to HHH, which means the DDD 
paired to that HHH, shows what the behavior of that input is.

And that behavior is that DDD calls HHH(DDD) which will emulate its 
input for awhile and then abort its emulation and return to DDD which 
will return, showing that DDD halts, and thus this HHH didn't NEED to 
abort its simulation, but does.

Of course, the different DDD, built on the different HHH that never 
aborts, does need to be aborted, but that is a different input.

The fact that you try to define DDD to NOT include that code for HHH 
just shows that you don't understand what a "Program" actually is, and 
that you figured by excluding it, you could LIE that all the inputs were 
the same, when they are not. Of course, by defining your input to not 
include the copy of HHH means your input isn't the representation of a 
program, and isn't actually emulatable, and thus your HHH isn't actually 
a halt decider, so everything you have said is shown to be a LIE.