Path: ...!weretis.net!feeder9.news.weretis.net!news.nk.ca!rocksolid2!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory
Subject: Re: Hypothetical possibilities
Date: Sat, 20 Jul 2024 22:55:19 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <a7083462cfb1761d0ee5691304714725c7794eca@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>
 <v7hokk$3phhn$1@dont-email.me>
 <6d3efd3e375c13ce1b313693d756734481804e52@i2pn2.org>
 <v7hpou$3pmkh$2@dont-email.me>
 <8423c2f75f2d88234a4b596778976d82c3382944@i2pn2.org>
 <v7hri8$3tn3h$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 21 Jul 2024 02:55:19 -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
In-Reply-To: <v7hri8$3tn3h$2@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0
Bytes: 8998
Lines: 173

On 7/20/24 10:25 PM, olcott wrote:
> On 7/20/2024 9:05 PM, Richard Damon wrote:
>> On 7/20/24 9:54 PM, olcott wrote:
>>> On 7/20/2024 8:51 PM, Richard Damon wrote:
>>>> On 7/20/24 9:35 PM, olcott wrote:
>>>>> On 7/20/2024 8:01 PM, Richard Damon wrote:
>>>>>> On 7/20/24 8:21 PM, olcott wrote:
>>>>>>> On 7/20/2024 7:05 PM, Richard Damon wrote:
>>>>>>>> On 7/20/24 7:06 PM, olcott wrote:
>>>>>>>>> On 7/20/2024 6:00 PM, Richard Damon wrote:
>>>>>>>>>> On 7/20/24 6:47 PM, olcott wrote:
>>>>>>>>>>> On 7/20/2024 5:11 PM, Richard Damon wrote:
>>>>>>>>>>>> On 7/20/24 5:21 PM, olcott wrote:
>>>>>>>>>>>>> On 7/20/2024 4:06 PM, joes wrote:
>>>>>>>>>>>>>> Am Sat, 20 Jul 2024 15:05:53 -0500 schrieb olcott:
>>>>>>>>>>>>>>> On 7/20/2024 2:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 7/20/24 3:09 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 7/20/2024 2:00 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>> Op 20.jul.2024 om 17:28 schreef olcott:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> (a) Termination Analyzers / Partial Halt Deciders 
>>>>>>>>>>>>>>>>>>> must halt this is
>>>>>>>>>>>>>>>>>>> a design requirement.
>>>>>>>>>>>>>>>>>>> (b) Every simulating termination analyzer HHH either 
>>>>>>>>>>>>>>>>>>> aborts the
>>>>>>>>>>>>>>>>>>> simulation of its input or not.
>>>>>>>>>>>>>>>>>>> (c) Within the hypothetical case where HHH does not 
>>>>>>>>>>>>>>>>>>> abort the
>>>>>>>>>>>>>>>>>>> simulation of its input {HHH, emulated DDD and 
>>>>>>>>>>>>>>>>>>> executed DDD}
>>>>>>>>>>>>>>>>>>> never stop running.
>>>>>>>>>>>>>>>>>>> This violates the design requirement of (a) therefore 
>>>>>>>>>>>>>>>>>>> HHH must abort
>>>>>>>>>>>>>>>>>>> the simulation of its input.
>>>>>>>>>>>>>> You missed a couple details:
>>>>>>>>>>>>>> A terminating input shouldn't be aborted, or at least not 
>>>>>>>>>>>>>> classified
>>>>>>>>>>>>>> as not terminating. Terminating inputs needn't be aborted; 
>>>>>>>>>>>>>> they and the
>>>>>>>>>>>>>> simulator halt on their own.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And when it aborts, the simulation is incorrect. When 
>>>>>>>>>>>>>>>>>> HHH aborts and
>>>>>>>>>>>>>>>>>> halts, it is not needed to abort its simulation, 
>>>>>>>>>>>>>>>>>> because it will halt
>>>>>>>>>>>>>>>>>> of its own.
>>>>>>>>>>>>>>>>> So you are trying to get away with saying that no HHH 
>>>>>>>>>>>>>>>>> ever needs to
>>>>>>>>>>>>>>>>> abort the simulation of its input and HHH will stop 
>>>>>>>>>>>>>>>>> running?
>>>>>>>>>>>>>> Pretty much.
>>>>>>>>>>>>>>>> It is the fact that HHH DOES abort its simulation that 
>>>>>>>>>>>>>>>> makes it not
>>>>>>>>>>>>>>>> need to.
>>>>>>>>>>>>>>> No stupid it is not a fact that every HHH that can 
>>>>>>>>>>>>>>> possibly exist aborts
>>>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>> I thought they all halt after a finite number of steps?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> void DDD()
>>>>>>>>>>>>> {
>>>>>>>>>>>>>     HHH(DDD);
>>>>>>>>>>>>>     return;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> DDD correctly simulated by pure function HHH cannot
>>>>>>>>>>>>> possibly reach its own return instruction.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Wrong.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You know that you are lying about this as you admit below:
>>>>>>>>>>
>>>>>>>>>> Nope, YOU just don't what the words mean, and reckless 
>>>>>>>>>> disregard the teaching you have been getting, which makes your 
>>>>>>>>>> errors not just honest mistakes but reckless pathological lies.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>> It may be that the simulation by HHH never reaches that point, 
>>>>>>>>>>>
>>>>>>>>>>>> but if HHH aborts its simuliaton and returns (as required 
>>>>>>>>>>>> for it to be a decider) then the behavior of DDD 
>>>>>>>>>>>
>>>>>>>>>>> Simulated by HHH is to Die, stop running, no longer function.
>>>>>>>>>>
>>>>>>>>>> Nope, HHH is NOT the "Machine" that determines what the code 
>>>>>>>>>> does, so can not "Kill" it.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So you are trying to get away with the lie
>>>>>>>>> that an aborted simulation keeps on running.
>>>>>>>>>
>>>>>>>>
>>>>>>>> No, but the BEHAVIOR of the program does, and that is what matters.
>>>>>>>
>>>>>>> So you agree that DDD correctly simulated by any pure function
>>>>>>> HHH cannot possibly reach its own return instruction?
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> No, I will let you claim (without proof, so we can argue tha 
>>>>>> later) that the simulation by HHH of DDD does not reach the 
>>>>>> return, but the behavior of the DDD simuliated by HHH continues, 
>>>>>> to the return if HHH aborts its simulation and returns, as the 
>>>>>> behavior of ALL copies of DDD do not "stop" just because some 
>>>>>> simulator gave up looking at it.
>>>>>>
>>>>>
>>>>> In other words you never understood that the input to an x86
>>>>> emulator is a static finite string of bytes that does not do
>>>>> anything at all on its own?
>>>>>
>>>>
>>>> But it represents a program that does,
>>>
>>> There is no representing to it.
>>> It is static data within the x86 emulator process.
>>>
>>
>>
>> In other words, you have just been lying for years about doing the 
>> Halting problem, whose input is the reperesentation of the program to 
>> be decided.
>>
>> No program to be decided on, no program to be emulated.
>>
> 
> There is never any representing involved when a simulator
> correctly simulates a finite string.

Then you just don't understand the nature of the problem. But then, that 
is an abstract concept which seems to be beyond your mental ability.

> 
> It has always been a mapping from the static finite string
> to the behavior specified by this finite string.

That is what the decider does, but not what determines that correct answer.

HHH gives exactly the answer you programmed it to do, (as all programs 
do), it just isn't the answer required by the problem.

But since you don't understand representation, and claim there isn't one 
involved, so the program can't actually be working on a problem that it 
has been defined to not be able to do, even though you claim it to do so.

The PROBLEM sand ays the input needs to be a representation of the 
program that you are asking about, but since you say that the input 
doesn't actually represent a program, it can't be a Halt Decider.

But even if we look past that lie, and ask about the ACTUAL BEHAVIOR of 
the program you are cliaiming it to be deciding, that would be the DDD() 
that calls the HHH(DDD) that gave the answer, and that program clearly 
halts, and thus an actual correct simulation of that program will halt, 
even if HHH's partial simulaition can't get there.

So, you are just buring you work under your pile of POOP. If the byte 
string is NOT supposed to be a representation of the program DDD(), then 
HHH just can not be a Halt Decider.
========== REMAINDER OF ARTICLE TRUNCATED ==========