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,sci.logic,comp.ai.philosophy
Subject: Re: Who here understands that the last paragraph is Necessarily True?
 --- AKA a Tautology
Date: Sat, 13 Jul 2024 16:57:16 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <a5affa5d9d9e1e14774884807cb233beaa8b9b52@i2pn2.org>
References: <v6uoh5$3o4oh$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 13 Jul 2024 20:57:16 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="3137773"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
In-Reply-To: <v6uoh5$3o4oh$1@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0
Content-Language: en-US
Bytes: 4109
Lines: 82

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
>