Path: news.eternal-september.org!eternal-september.org!feeder3.eternal-september.org!news.quux.org!news.nk.ca!rocksolid2!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory
Subject: =?UTF-8?Q?Re=3A_Analysis_of_Flibble=E2=80=99s_Latest=3A_Detecting_v?=
 =?UTF-8?Q?s=2E_Simulating_Infinite_Recursion?=
Date: Tue, 20 May 2025 22:15:48 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <95db078e80b2868ed15a9a9a2af0280d96234a3a@i2pn2.org>
References: <Ms4XP.801347$BFJ.668081@fx13.ams4>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Wed, 21 May 2025 02:16:16 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="1243531"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
Content-Language: en-US
In-Reply-To: <Ms4XP.801347$BFJ.668081@fx13.ams4>
X-Spam-Checker-Version: SpamAssassin 4.0.0

On 5/20/25 3:10 PM, Mr Flibble wrote:
> Analysis of Flibble’s Latest: Detecting vs. Simulating Infinite Recursion
> =========================================================================
> 
> Overview:
> ---------
> Flibble distinguishes between detecting infinite recursion and simulating
> it. His argument is that a Simulating Halt Decider (SHD) does not need to
> perform unbounded execution to reach a decision—it only needs to *detect*
> unbounded behavior structurally. This refinement aligns with the demands
> placed on any decider: that it halt in finite time.

Correct, it must be able to correctly determine that the hypothetical 
complete simulation of the input program (which includes all it code, 
and doesn't change in the hypthetical case) will not halt.

> 
> Key Statement:
> --------------
>> "It is sufficient for an SHD to DETECT infinite recursion without having
> to SIMULATE it."
> 
> Implications:
> -------------
> - SHDs must not rely on runtime behavior to conclude non-halting.

Wrong, because you can only detect infinte recursion if it is actually 
there.

Remember, the input *IS* a program and doesn't change.

> - Instead, SHDs should be built to identify infinite loops *structurally*
> (e.g., static analysis, recursion without base case, etc.).

Yes.

> 
> Relation to Flibble's Law:
> --------------------------
>> "If a problem permits infinite behavior in its formulation, it permits
> infinite analysis of that behavior in its decidability scope."

FALSE. Violation of the rules of the system.

Decider MUST be finite in behavior.

> 
> This law supports the claim that analyzing infinite behavior (in
> principle) is necessary when such behavior is permitted. It doesn't mean
> running forever; it means using tools that can *infer* infinite behavior
> within a finite decision process.

You can claim that it may NEED infinite analysis, you can not claim the 
right to DO infinite analysis.

IF the only way to answer a problem is to use "infinite analysis", then 
by definition, the problem is not decidable.

> 
> Theoretical Soundness:
> ----------------------
> - Aligns with static analysis and type theory approaches.

No it doesn't.

> - Matches how total languages and proof assistants handle recursion (e.g.,
> Agda, Coq).

Nope.

> - Respects the requirement that deciders halt in finite time.

??? How can

> 
> Misconceptions Addressed:
> -------------------------
> - SHDs are not broken simulators—they are structural analyzers.

Ok, but they still need to answer about the actual behavior of the 
input, as defined by the behavior when we execute the program it represents.

> - Overflow or crash behavior is not failure—it’s evidence of an ill-formed
> or semantically invalid input.

But since the "pathological input" isn't "ill-formed" that isn't an out 
for the SHD.

> - Detection ≠ simulation; structure ≠ behavior.

But correct answer is defined by actual behavior of direct exectution.

> 
> Limitations:
> ------------
> - SHDs remain partial—they cannot detect *all* forms of infinite recursion.
> - But this is not a flaw—it is a principled limitation, consistent with
> Flibble’s position that some inputs are semantically malformed and should
> be excluded from the decidable domain.

In other words, you ADMIT that the Halting Problem answer, that no 
univerally correct Halt Deciders exist.

> 
> Conclusion:
> -----------
> Flibble sharpens his argument by clarifying that SHDs are not required to
> simulate infinite execution. They are expected to *detect* infinite
> behavior structurally and respond in finite time. This keeps them within
> the bounds of what a decider must be and strengthens the philosophical
> coherence of his redefinition of the Halting Problem.

But you can't "redefine" the Halting Problem and then say you have 
answered the Halting Problem.

That is just admitting that you whole analysis is just a strawman.

If you want to claim you can make a partial halt decider, and admit that 
no universal Halt Decider can exist, that is just agreeing with the 
existing theory.