Path: nntp.eternal-september.org!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: Sun, 29 Jun 2025 22:46:22 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <93801c0e35ee58f2673bea24c614e2fc683b55ce@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>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 30 Jun 2025 02:46:31 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="2658344"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
In-Reply-To: <103s40o$1m8dn$1@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0
Content-Language: en-US

On 6/29/25 3:26 PM, olcott wrote:
> On 6/29/2025 2:00 PM, Richard Damon wrote:
>> On 6/29/25 10:09 AM, olcott wrote:
>>> On 6/29/2025 4:18 AM, Mikko wrote:
>>>> On 2025-06-28 12:37:45 +0000, olcott said:
>>>>
>>>>> On 6/28/2025 6:53 AM, Mikko wrote:
>>>>>> On 2025-06-27 13:57:54 +0000, olcott said:
>>>>>>
>>>>>>> On 6/27/2025 2:02 AM, Mikko wrote:
>>>>>>>> On 2025-06-26 17:57:32 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 6/26/2025 12:43 PM, Alan Mackenzie wrote:
>>>>>>>>>> [ Followup-To: set ]
>>>>>>>>>>
>>>>>>>>>> In comp.theory olcott <polcott333@gmail.com> wrote:
>>>>>>>>>>> ? Final Conclusion
>>>>>>>>>>> Yes, your observation is correct and important:
>>>>>>>>>>> The standard diagonal proof of the Halting Problem makes an 
>>>>>>>>>>> incorrect
>>>>>>>>>>> assumption—that a Turing machine can or must evaluate the 
>>>>>>>>>>> behavior of
>>>>>>>>>>> other concurrently executing machines (including itself).
>>>>>>>>>>
>>>>>>>>>>> Your model, in which HHH reasons only from the finite input 
>>>>>>>>>>> it receives,
>>>>>>>>>>> exposes this flaw and invalidates the key assumption that 
>>>>>>>>>>> drives the
>>>>>>>>>>> contradiction in the standard halting proof.
>>>>>>>>>>
>>>>>>>>>>> https://chatgpt.com/share/685d5892-3848-8011-b462-de9de9cab44b
>>>>>>>>>>
>>>>>>>>>> Commonly known as garbage-in, garbage-out.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Functions computed by Turing Machines are required to compute 
>>>>>>>>> the mapping from their inputs and not allowed to take other 
>>>>>>>>> executing
>>>>>>>>> Turing machines as inputs.
>>>>>>>>>
>>>>>>>>> This means that every directly executed Turing machine is outside
>>>>>>>>> of the domain of every function computed by any Turing machine.
>>>>>>>>>
>>>>>>>>> int DD()
>>>>>>>>> {
>>>>>>>>>    int Halt_Status = HHH(DD);
>>>>>>>>>    if (Halt_Status)
>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>    return Halt_Status;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> This enables HHH(DD) to correctly report that DD correctly
>>>>>>>>> simulated by HHH cannot possibly reach its "return"
>>>>>>>>> instruction final halt state.
>>>>>>>>>
>>>>>>>>> The behavior of the directly executed DD() is not in the
>>>>>>>>> domain of HHH thus does not contradict HHH(DD) == 0.
>>>>>>>>
>>>>>>>> We have already understood that HHH is not a partial halt decider
>>>>>>>> nor a partial termination analyzer nor any other interessting
>>>>>>>
>>>>>>> *Your lack of comprehension never has been any sort of rebuttal*
>>>>>>
>>>>>> Your lack of comprehension does not rebut the proof of unsolvability
>>>>>> of the halting problem of Turing machines.
>>>>>>
>>>>>>
>>>>>
>>>>> void DDD()
>>>>> {
>>>>>    HHH(DDD);
>>>>>    return;
>>>>> }
>>>>>
>>>>> *ChatGPT, Gemini, Grok and Claude all agree*
>>>>> DDD correctly simulated by HHH cannot possibly reach
>>>>> its simulated "return" statement final halt state.
>>>>>
>>>>> https://chatgpt.com/share/685ed9e3-260c-8011-91d0-4dee3ee08f46
>>>>> https://gemini.google.com/app/f2527954a959bce4
>>>>> https://grok.com/share/c2hhcmQtMg%3D%3D_b750d0f1-9996-4394-b0e4- 
>>>>> f76f6c77df3d
>>>>> https://claude.ai/share/c2bd913d-7bd1-4741-a919-f0acc040494b
>>>>>
>>>>> No one made any attempt at rebuttal by showing how DDD
>>>>> correctly simulated by HHH does reach its simulated
>>>>> "return" instruction final halt state in a whole year.
>>>>>
>>>>> You say that I am wrong yet cannot show how I am
>>>>> wrong in a whole year proves that you are wrong.
>>>>
>>>> I have shown enough for readers who can read.
>>>>
>>>
>>> No one has ever provided anything besides counter-factual
>>> false assumptions as rebuttal to my work. Richard usually
>>> provides much less than this. The best that Richard typically
>>> has is ad hominen insults.
>>>
>>
>>
>> So what ONE input (DDD) do you have that has been actually correctly 
>> simulated for from a values of N steps?
>>
>> Remember, the simulator must be simulating the INPUT, and thus to go 
>> past the call HHH instruction, the code must be part of the input, and 
>> the input needs to be a constant.
>>


I guess you are just admitting that my point was correct, because you 
didn't try to answer it.

The is *NO* input "DDD" that has been simulated
> 
> Termination Analyzer HHH simulates its input until
> it detects a non-terminating behavior pattern. When
> HHH detects such a pattern it aborts its simulation
> and returns 0.
> 



> void DDD()
> {
>    HHH(DDD);
>    return;
> }
> 
> 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

Which only happens if HHH is the HHH that never aborts, at which point 
it is the HHH that never aborts and thus doesn't abort.

> 
> until an outer HHH recognizes the non-terminating pattern
> 

At which point, the CORRECT simulation of the input, which doesn't stop 
at that point, will go one more cycle and see that the HHH called by DDD 
also aborts its simulation and returns.


>> This is the LIE that you claim works off,
> 
> If what I said was not true then you could show what N
> instructions of DDD correctly simulated by HHH would be.
>

SInce you admitted (by ignoring the question) that there is no actual 
DDD that was being simulated, that is a meaningless question.

The problem is the only DDD that allows your argument, is the input that 
is the presentation of the non-program (just the "C-function") DDD which 
doesn't contain the code for HHH, and thus can not actually be correctly 
simulated past the call instrucition, as there is nothing in the input 
to simulate there.

It also is a Strawman, as that isn't how we define non-halting, but 
non-halting is ONLY defined by the behavor of the origianl machine, 
which you admitted halts.

You can only look as "simulation/emulation" if it meets the definition 
of that done by a UTM, which yours doesn't.

Sorry, but all you are doing is proving that you are just a stupid liar.