Re: What I told ChatGPT is essentially identical to the first page of my paper

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() ?