Who here understands that the last paragraph is Necessarily True? --- AKA a Tautology

[olcott]

*Pure function HHH is a simulating termination analyzer*
DDD is correctly simulated by HHH until HHH correctly
determines that it must abort its simulation of DDD
to prevent its own non-termination.

typedef void (*ptr)();
int HHH(ptr P);

void Infinite_Loop()
{
HERE: goto HERE;
}

void Infinite_Recursion()
{
Infinite_Recursion();
}

void DDD()
{
HHH(DDD);
}

int main()
{
HHH(Infinite_Loop);
HHH(Infinite_Recursion);
HHH(DDD);
}

Any input that must be aborted to prevent the non
termination of HHH necessarily specifies non-halting
behavior or it would never need to be aborted.

https://www.researchgate.net/publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

[Richard Damon]

Post by olcott
*Pure function HHH is a simulating termination analyzer*
DDD is correctly simulated by HHH until HHH correctly
determines that it must abort its simulation of DDD
to prevent its own non-termination.

Which you need to prove is possible and still gets the right answer.

Post by olcott
typedef void (*ptr)();
int HHH(ptr P);
void Infinite_Loop()
{
  HERE: goto HERE;
}
void Infinite_Recursion()
{
  Infinite_Recursion();
}
void DDD()
{
  HHH(DDD);
}
int main()
{
  HHH(Infinite_Loop);
  HHH(Infinite_Recursion);
  HHH(DDD);
}
Any input that must be aborted to prevent the non
termination of HHH necessarily specifies non-halting
behavior or it would never need to be aborted.

But if HHH does abort its simulation, as you have defined to avoid
getting stuck in an infinite processing, means that its input will call
the HHH that does the same, i.e DDD calls an HHH that WILL abort its
simulation and return its answer.

This means that if we give this exact input, the DDD that calls that HHH
that aborts its simulation and returns to an actual pure simulator that
continues until it reaches the final state, that simulator will simulete
DDD calling HHH(DDD) and that then simulating for a while and the it
WILL abort its simulation (since that is what your original HHH did) and
then return to DDD that returns.

THus, it is NOT correct that HHH needed to abort its simulation of THIS
input (which it happened to do), so it is incorrect in assuming that its
input is non-halting.

The problem is that the DEFINITION of termination analyzers is that they
take as input descriptions of FULL PROGRAMS, which inlcude ALL the code
of that program, and thus to anaylyze DDD it is also given the code for
the HHH that it is paired with.

When you iterate over every possible HHH, and the DDD created by pairing
it with that HHH, you get a DIFFERENT input for each analyzer, and thus
the fact that the HHH that did simulate forever didn't stop doesn't mean
that the simulators that do abort their simulation can look at that
non-aborting HHH to see the behavior of THEIR OWN input.

You need to give THIS INPUT, tied to THIS HHH to that non-aborting HHH
and it will simulate the full behiavor of that HHH that aborted and see
it return to DDD which will return and thus that HHH was incorrect in
its decision.

YOu are just proving that you have insufficient knowledge of the field
you are talking about, or even logic in general, to make a viable claim.

SORRY, you have wasted you life working on the lies you convinced
yourself of because you chose to make yourself ignorant of the basic
principles of the fields you wanted to talk about, and (incorrectly)
presumed you could just "guess" what those system do by casual perusal
of imprecise, and even incorrect articles.

Post by olcott
https://www.researchgate.net/publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D