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: What I told ChatGPT is essentially identical to the first page of
 my paper
Date: Sun, 20 Oct 2024 15:13:33 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <6fa1774ec1e4b13035be3eab85555b609b301d69@i2pn2.org>
References: <vf3eu5$fbb3$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 20 Oct 2024 19:13:34 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="2925119"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
X-Spam-Checker-Version: SpamAssassin 4.0.0
Content-Language: en-US
In-Reply-To: <vf3eu5$fbb3$2@dont-email.me>
Bytes: 4880
Lines: 105

On 10/20/24 1:33 PM, olcott wrote:
> This is the only new material that sums up the
> essence of what a simulating termination analyzer is.
> 
> 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.

But for the pattern that it detects to be correct, it must be that all 
input that exhibit that pattern must never halt when run.

> 
> All of the follows is simply cut-and-paste from my paper
> except that I added DDD(DDD) call in main().
> https://chatgpt.com/share/6709e046-4794-8011-98b7-27066fb49f3e

But your input LIES, as you say:

When this is construed as non-halting criteria then simulating 
termination analyzer HHH is correct to reject this input as non-halting 
by returning 0 to its caller.

We get the same repetitive pattern when DDD is correctly emulated by 
HHH. HHH emulates DDD that calls HHH(DDD) to do this again.



But the emulaiton of infinite+_recursion show a trace that has 
infinite_recursion calling in that execution context another copy of 
infinite_recursion with nothing in the loop that could break the pattern.

When we emulate DDD, we NEVER get to a point where we ever see in that 
execution context a call to DDD, only the code begin to emulate that 
code, and the emulation of the emulator shows that such emulation is 
being done conditionally, and if the proper conditions are meet, that 
emulation WILL abort its emulation and return.

And, we can see that if this HHH has code to terminate its emulation, 
and that HHH is the exact same code, and that code is actually a pure 
function, then that emulated copy of HHH will also eventually reach that 
point if we emulated it far enough past the point the outer was was 
programmed to abort.

The fact that the outer HHH can't do that as it isn't what it was 
programmed to do, doesn't undo the fact that we can see that this *IS* 
the behavior of a correct and complete emulation of the input actually 
given to HHH.

So, you claim is a LIE when it says that "when HHH does a correct 
emulation" when you HHH actually never DOES a correct emualation per the 
definitions of an emulation that shows "never halts" (and thus by the 
acrtual definition you are trying to use, we can make a trivial version 
that reports (virtually) all machines as non-halting)

All you have done is proved that you LIED about the conditions, and LIED 
that the "finite-string" you gave as the input was actually a proper 
representation of the input PROGRAM.

Thus proving you don't understand what a PROGRAM actually is, and that 
you have been lying that you have followed the methods described in the 
paper you are trying to refute.

> 
> Simulating Termination Analyzer H is Not Fooled by Pathological Input D
> https://www.researchgate.net/ 
> publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
> 
> Everything below is verbatim cut-and-paste from my above paper.
> 
> typedef void (*ptr)();
> int HHH(ptr P);
> 
> void Infinite_Recursion()
> {
>    Infinite_Recursion();
> }
> 
> void DDD()
> {
>    HHH(DDD);
>    return;
> }
> 
> int main()
> {
>    HHH(Infinite_Recursion);
>    HHH(DDD);
>    DDD(DDD);
> }
> 
> Every C programmer that knows that when HHH emulates the machine 
> language of, Infinite_Recursion it must abort this emulation so that 
> itself can terminate normally.
> 
> When this is construed as non-halting criteria then simulating 
> termination analyzer HHH is correct to reject this input as non-halting 
> by returning 0 to its caller.
> 
> We get the same repetitive pattern when DDD is correctly emulated by 
> HHH. HHH emulates DDD that calls HHH(DDD) to do this again.
> 
> Do the function calls from main() return to main() ?
>