Path: news.eternal-september.org!eternal-september.org!feeder3.eternal-september.org!usenet.network!news.neodome.net!rocksolid2!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory
Subject: Re: ChatGPT agrees that HHH refutes the standard halting problem
 proof method
Date: Tue, 1 Jul 2025 21:25:27 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <ad226236ac9c5a709ba9fff6268f52c5aeb0c5f0@i2pn2.org>
References: <103jmr5$3h0jc$1@dont-email.me> <103k0sc$2q38$1@news.muc.de>
 <103k1mc$3j4ha$1@dont-email.me> <103lfn1$ml0$1@dont-email.me>
 <103m813$6dce$1@dont-email.me> <103ol2u$raq9$1@dont-email.me>
 <103onmp$rq7e$1@dont-email.me> <103r0ce$1esb9$1@dont-email.me>
 <103rhf6$1hc53$8@dont-email.me>
 <0c50a8ee4efb36cef4271674792a090125187f9d@i2pn2.org>
 <103s40o$1m8dn$1@dont-email.me>
 <93801c0e35ee58f2673bea24c614e2fc683b55ce@i2pn2.org>
 <103sutf$1utb9$1@dont-email.me>
 <3cbdc10609ef73de4d91adaa33cded8cef5117f6@i2pn2.org>
 <103ufqg$292c0$3@dont-email.me>
 <17a2593ee804665b9f412c522a6f64c7618c202f@i2pn2.org>
 <103vdgi$2flaf$1@dont-email.me>
 <ea71d52059ab645fa0360dfcfd8923749e9e8324@i2pn2.org>
 <1040j2b$2ql69$6@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Wed, 2 Jul 2025 01:31:49 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="2962761"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
In-Reply-To: <1040j2b$2ql69$6@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0
Content-Language: en-US

On 7/1/25 8:07 AM, olcott wrote:
> On 7/1/2025 6:28 AM, Richard Damon wrote:
>> On 6/30/25 9:26 PM, olcott wrote:
>>> On 6/30/2025 8:10 PM, Richard Damon wrote:
>>>> On 6/30/25 1:00 PM, olcott wrote:
>>>>>
>>>>> One line of C source-code is a C statement.
>>>>> HHH simulates six statements of DDD.
>>>>
>>>> No it doesn't, as that line of C refers to HHH, and to process that 
>>>> line, you need to process ALL the lines in HHH.
>>>>
>>>
>>> Yes this is true.
>>> What the F did you think that I meant by:
>>>
>>> HHH simulates DDD that calls HHH
>>> that simulates DDD that calls HHH
>>> that simulates DDD that calls HHH
>>> that simulates DDD that calls HHH
>>> that simulates DDD that calls HHH
>>> that simulates DDD that calls HHH...
>>
>> Except that isn't what you said HHH does!
>>
>> YOu said HHH simulated DDD until it recognizes a non-halting pattern.
>>
>> You have omitted this in your "loop"
>>
> 
> Recursive emulation is not a loop.

But the description is.

Attempted side track again, because you can't answer the refutation.



> 
>> It should be:
>> HHH simulated DDD that calls HHH, until it recognizes a non-halting 
>> pattern,
>> Which results in it simulating HHH simulating DDD until it recognizes 
>> a non-halting pattern...
>> Which results in it simulating HHH simulating DDD until it recognizes 
>> a non-halting pattern...
>> Which results in it simulating HHH simulating DDD until it recognizes 
>> a non-halting pattern...
>> Which results in it simulating HHH simulating DDD until it recognizes 
>> a non-halting pattern...
>>
> 
> It is more precisely accurate the way that you
> did it yet too confusing to get the gist of the
> idea of recursive emulation.

No, your method just adds enough LIE to seem to support you LIE.

This is just your normal modus operandi, you need to "simplify" a 
statement to be "more understandable", but in doing so you twist its 
meaning so it is no longer correct.

It seems "Truth" and "Correct" are not important concepts to you, but 
then, you have proven yourself to be a pathological liar, so that is 
expected.

> 
>> The problem is when you include that we KNOW that, since the outer HHH 
>> *WILL* at some point abort (since you assume that will happen) that 
>> this simulated HHH will also do that, and thus make the DDD that 
>> called it halting.
>>
> 
> If you are going to call impossibly reaching its final halt state
> halting you might as well call it also makes you breakfast in bed.

But it isn't impossible for the machine to reach its final state (if it 
is built on an actual decider).

It is just impossible to make a version of it that this state can be 
reached by its decider.

And, as I said, if HHH is a decider, then DDD does halt.

You are just stuck in your lying strawman "definition" of Halting, since 
you forget what it is that needs to reach the final state.

> 
>> Your problem is you didn't CORRECTLY simulate the HHH that DDD calls, 
>> as you ERRONEOUSLY assumed that it will not halt in order to claim 
>> that you have a non-halting pattern.
>>
> 
> When N x86 instructions of DDD are simulated
> according to the semantics of the x86 language
> then N N x86 instructions of DDD are simulated
> correctly. This includes HHH simulating itself
> simulating DDD at least once.

WHich just isn't a COMPLETE CORRECT simulation, which is what the 
meaning of "Correct Simulation" refers to.

I guess you think getting the first question (like putting in your name) 
on the IQ test and then stopping means you correctly answered the test.

> 
> I don't understand why this is so difficult for
> you unless you grossly exaggerated your competence
> at programming.

It isn't, because I know the right definitions.

What is surprising is how slow you are proving that you are, by just 
flat out refusing to accept that correct definitions and hold onto you lies.

> 
>> THe problem is whatever criteria is used to abort, is part of the code 
>> that is being analyized, and thus you need to take that into account 
>> when you try to prove that the pattern is non-halting.
>>
> 
> Repeat this to yourself 500 times so that you will
> remember it by the time you make your next reply.
> 
> *DDD correctly simulated by HHH cannot possibly reach*
> *its own simulated "return" statement final halt state*
> 
> *DDD correctly simulated by HHH cannot possibly reach*
> *its own simulated "return" statement final halt state*
> 
> *DDD correctly simulated by HHH cannot possibly reach*
> *its own simulated "return" statement final halt state*

And the HHH that answers does not correct simulate ITS DDD, and has a 
different DDD then the one that was correctly simulated by a different HHH.

It seems you don't understand that fact.

Or, you statement is just a total lie, because you think DDD doesn't 
include the code for HHH as part of it, at which point NO HHH correctly 
simulates it, since a correct simulation of a program fragment that 
tries to use the routine that isn't part of it is just impossible, since 
it turns out not to be a program, and doesn't have behaivor.

This is one of your fundamental basis of lies in your logic.

Your "logic" has an essental equivocation on what the input is, which 
yoy can't clearify, as what ever answer you give you end up admitting 
that you have been lying.

Sorry, all you are doing is showing that you are so stupid you can't 
undetstand that simple of a problem with your "logic"

> 
>> Your "logic" doesn't understand how programs work and are defined, 
>> because your "logic" comes out of your own ignorance of the field.
>>
>>>
>>>
>>>> You are just showing you don't understand the basics of how 
>>>> computers and programs work.
>>>>
>>>>>
>>>>>> Note, "C" doesn't define "instructions", but operations as defined 
>>>>>> by the abstract machine.
========== REMAINDER OF ARTICLE TRUNCATED ==========