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: Philosophy of Computation: Three seem to agree how emulating
 termination analyzers are supposed to work
Date: Sun, 10 Nov 2024 22:55:46 -0500
Organization: i2pn2 (i2pn.org)
Message-ID: <0f07d6341f3f84f724c2977b5701daa5cf06ab28@i2pn2.org>
References: <vgr1gs$hc36$1@dont-email.me>
 <114d7d0cb5266295ec2c9e9097158d78e5f51dea@i2pn2.org>
 <vgr9i1$ikr6$1@dont-email.me>
 <06be2ab9cc3801f1b97e9000ce0150aa4a88b520@i2pn2.org>
 <vgrf2h$jtb3$1@dont-email.me>
 <ed90976d73f20c2764c159ec03b27b3db0ecddae@i2pn2.org>
 <vgrj1r$kgn0$1@dont-email.me>
 <f0e1d98f143f3b0f00756a765d7328898a7ef4cc@i2pn2.org>
 <vgrpae$lf0f$1@dont-email.me>
 <fd853510de113d7c5e236b96ecde0e5a5dba2e59@i2pn2.org>
 <vgrt2q$ptds$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Mon, 11 Nov 2024 03:55:47 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="1908296"; 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: <vgrt2q$ptds$1@dont-email.me>
Bytes: 7208
Lines: 138

On 11/10/24 10:18 PM, olcott wrote:
> On 11/10/2024 9:09 PM, Richard Damon wrote:
>> On 11/10/24 9:14 PM, olcott wrote:
>>> On 11/10/2024 7:20 PM, Richard Damon wrote:
>>>> On 11/10/24 7:27 PM, olcott wrote:
>>>>> On 11/10/2024 6:06 PM, Richard Damon wrote:
>>>>>> On 11/10/24 6:19 PM, olcott wrote:
>>>>>>> On 11/10/2024 4:53 PM, joes wrote:
>>>>>>>> Am Sun, 10 Nov 2024 15:45:37 -0600 schrieb olcott:
>>>>>>>>> On 11/10/2024 3:02 PM, Richard Damon wrote:
>>>>>>>>>> On 11/10/24 2:28 PM, olcott wrote:
>>>>>>>>
>>>>>>>>>>> If simulating halt decider H correctly simulates its input D 
>>>>>>>>>>> until H
>>>>>>>>>>> correctly determines that its simulated D would never stop 
>>>>>>>>>>> running
>>>>>>>>>>> unless aborted then
>>>>>>>>>> Right, if the correct (and thus complete) emulation of this 
>>>>>>>>>> precise
>>>>>>>>>> input would not halt.
>>>>>>>>> That is what I have been saying for years.
>>>>>>>> If.
>>>>>>>>
>>>>>>>>>>> H can abort its simulation of D and correctly report that D 
>>>>>>>>>>> specifies
>>>>>>>>>>> a non-halting sequence of configurations.
>>>>>>>>>>> </MIT Professor Sipser agreed to ONLY these verbatim words 
>>>>>>>>>>> 10/13/2022>
>>>>>>>>>> Which your H doesn't do.
>>>>>>>>> It is a matter of objective fact H does abort its emulation and 
>>>>>>>>> it does
>>>>>>>>> reject its input D as non-halting.
>>>>>>>
>>>>>>>> And then it returns to the D that called it, which then halts 
>>>>>>>> anyway.
>>>>>>>
>>>>>>> Maybe you are not as smart as ChatGPT.
>>>>>>> ChatGPT cannot be convinced that HHH was not correct
>>>>>>> to reject DDD as non-halting and explains in its own
>>>>>>> words why the fact that DDD halts does not change this.
>>>>>>
>>>>>> Sure it can. I did it, when I gave it a CORRECT description of the 
>>>>>> problem, it admits that your criteria for HHH is incorrect, and 
>>>>>> DDD does halt and HHH should have reported Halting.
>>>>>>
>>>>>
>>>>> When you try to argue that HHH does not correctly determine
>>>>> that halt status of DDD within the succinct basis that I
>>>>> provided you fail because my reasoning is inherently correct
>>>>> within this basis.
>>>>>
>>>>> You can't even convince it that my basis is based on false
>>>>> assumptions it knows better.
>>>>>
>>>>>>>
>>>>>>> ChatGPT
>>>>>>> Simplified Analogy:
>>>>>>> Think of HHH as a "watchdog" that steps in during real execution
>>>>>>> to stop DDD() from running forever. But when HHH simulates DDD(),
>>>>>>> it's analyzing an "idealized" version of DDD() where nothing 
>>>>>>> stops the
>>>>>>> recursion. In the simulation, DDD() is seen as endlessly 
>>>>>>> recursive, so
>>>>>>> HHH concludes that it would not halt without external intervention.
>>>>>>
>>>>>> Which has several lies in it, so makes your proof invalid.
>>>>>>
>>>>>>>
>>>>>>> https://chatgpt.com/share/67158ec6-3398-8011-98d1-41198baa29f2
>>>>>>> This link is live so you can try to convince ChatGPT that its wrong.
>>>>>>>
>>>>>>> DDD emulated by HHH has different behavior than DDD emulated
>>>>>>> by HHH1 and it is becoming psychotic to keep ignoring this.
>>>>>>>
>>>>>>
>>>>>> No, a correct emulation of ANY program will be the same no matter 
>>>>>> what emulator looks at it.
>>>>>>
>>>>>
>>>>> No stupid this is not true.
>>>>> You are stupid to disagree with the x86 language that
>>>>> does proves that HHH emulates itself emulating DDD and
>>>>> HHH1 does not emulate itself emulation DDD.
>>>>>
>>>>> Are you going for a prize of maximum stupidity?
>>>>>
>>>>
>>>> The problem is that you "basis" is just a lie, and doesn't meet the 
>>>> requirements for a property to be decided by a decider.
>>>>
>>>
>>> That you think that you can get away with disagreeing with the
>>> semantics of the x86 language for termination analyzer HHH
>>> seems a little too stupid, thus we seem to be only left with
>>> dishonestly.
>>
>> WHERE did I disagree with the semantics of the x86 language?
>>
>> You are just up to your old lies again.
>>
>> The best judge of the x86 language is running the program described by 
>> the input on a real CPU.
>>
>> DDD() halts, so NOTHING in the x86 semantics can say otherwise, just 
>> your LIES where you don't undetstand how computers actually work.
>>
> 
> Saying that DDD() halts when you know damn well that
> DDD emulated by HHH does not halt is a damned lie that
> could get you condemned to actual Hell.
> 

But DDD emulated by HHH doesn't say what the correct emulation per the 
x86 language defines, since your HHH doesn't do a correct emulation 
since it aborts its emulation, which isn't according to the semantics of 
the x86 language, so you statement is just a lying strawman.

Sorry, making false claims like you do just proves that you are nothing 
but an ignorant pathological lying idiot.

IF you can show a reliable reference that says that a correct smeantics 
of a program can be defined by only a partial emulation of it, go ahead. 
(Note, not that some program might be able to compute the answer with a 
partial emulatio, but that the results of the partial emulation DEFINES 
what the answer is).

If you can show a reliable reference that says that the correct 
determinati0n for a halting problem is correctly based on your criteria, 
go ahead an provide it.

Your problem is you don't actually know the rules, but have made them up 
based on your imperfect analysis of the field, and then you lie and 
claim to be an expert.

You are just proving that nobody should ever trust anything you say, 
because you are nothing but an ignorant pathetic pathological lying 
idiot, that has no idea of the meaning of the words he is using, and no 
respect for the truth.