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

On 7/13/24 4:36 PM, olcott wrote:

*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.

 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.

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