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: Re: Analysis of Richard Damon's Responses to Flibble's Detection
 Argument
Date: Wed, 21 May 2025 21:21:58 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <742e31a8963c94b7b47d58769f00d1eb3890ab2f@i2pn2.org>
References: <YAoXP.1292871$4AM6.652919@fx17.ams4>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 22 May 2025 01:36:01 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="1378644"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
In-Reply-To: <YAoXP.1292871$4AM6.652919@fx17.ams4>
X-Spam-Checker-Version: SpamAssassin 4.0.0
Content-Language: en-US

On 5/21/25 2:04 PM, Mr Flibble wrote:
> Analysis of Richard Damon's Responses to Flibble's Detection Argument
> =====================================================================
> 
> Overview:
> ---------
> Richard Damon's latest response to Flibble's refined position on
> Simulating Halt Deciders (SHDs) and infinite recursion continues to apply
> classical Turing logic to a fundamentally different model. This leads to
> multiple critical misinterpretations and categorical mismatches in
> reasoning.

THen you are willing to admit that you system has no impact on the 
classical Halting Problem, and thus does "solve" that problem?

> 
> 1. Misunderstanding Detection vs. Simulation
> --------------------------------------------
> Damon says:
>> "Wrong, because you can only detect infinite recursion if it is actually
> there."
> 
> Flibble never claims detection occurs without cause. He asserts that
> *some* forms of infinite recursion can be detected **structurally**—
> without runtime simulation. Damon’s assumption that only simulation can
> confirm recursion ignores the entire field of static analysis.

So, if the input program doesn't actually have infinite recursion, your 
decider would be incorrect to say it is there?

> 
> Flibble's approach mirrors:
> - Structural analysis in compilers.
> - Termination proofs in dependently typed languages.
> 
> 2. Rigid and Misapplied Conception of Decidability
> ---------------------------------------------------
> Damon says:
>> "Violation of the rules of the system."
> 
> Flibble agrees that deciders must halt in finite time. His law refers to
> the *necessity* of reasoning about infinite behavior—not to *performing*
> infinite computation.

So you don't understand the objection. To *BE* a decider, it must be a 
program with fully defined operations and thus fully defined behavor for 
any input. THus H(D) will ALWAYS give the same result.

That means that the "pathological" program built on it will also be 
fully defined in operation, and thus fully defined behavior for any 
input it is given. Thus D() will ALWAYS do the same thing, no matter 
who/what is looking at it.

> 
> Damon's response assumes that *mentioning* infinity implies unbounded
> execution, which misconstrues Flibble’s meta-theoretical intent.

Nope. That comment just says you don't understand what I am talking about.

> 
> 3. Incorrect Dismissal of Type Theory and Proof Assistants
> -----------------------------------------------------------
> Damon says:
>> "No it doesn't." (on alignment with Coq/Agda)
> 
> This is false. Proof assistants like Agda and Coq use:
> - Structural recursion.
> - Finite proofs to ensure termination.
> 
> Flibble’s SHD aligns with these practices by seeking **compile-time
> recognizability** of non-termination. Damon mischaracterizes these
> systems, likely from lack of direct experience with their constraints.

But the fact that DD() does terminate means that it is IMPOSSIBLE for 
the decider to somehow correctly determined that it doesn't

> 
> 4. Misframing Overflow as Error Instead of Signal
> --------------------------------------------------
> Damon says:
>> "Overflow... isn't an out for the SHD."
> 
> Flibble argues that stack overflow is a **semantic indicator** of an ill-
> posed question, not an execution failure. This is analogous to:
> - Type errors in type-safe languages.
> - Runtime protection against undefined behavior.

No stack overflow is not allowed in Turing Complete systems, and when 
using finite approximatios for Turing Complete systems, it indictes a 
inability of the system to handle the problem.

> 
> Damon views overflow through a hardware lens, while Flibble interprets it
> as a meta-semantic signal—again, a mismatch of frameworks.

Ok, so you are just admitting you "framework" is insufficient for the 
probmme.

> 
> 5. False Strawman Accusation
> -----------------------------
> Damon says:
>> "You can't redefine the Halting Problem and then say you have answered
> it."
> 
> Flibble does **not** claim to solve the Halting Problem. He claims:
> - The classical framing is ill-typed or semantically malformed in
> pathological cases.
> - A meaningful reformulation avoids this by respecting type/category
> boundaries.
> 
> Damon misreads Flibble's reframing as a refutation, then attacks that
> strawman.
> 
> 6. Conceding Without Recognizing It
> ------------------------------------
> Damon says:
>> "You ADMIT that... no universal Halt Decider exists."
> 
> Yes—Flibble agrees. The disagreement is not about the *result*, but about
> the *reason*.

But if you claim to be talking about the REASON that the Halting Problem 
doesn't work, IN ITS SYSTEM, you have to use ITS SYSTEM.

Sorry, you are just admitting you are starting with a category error.

> 
> | Turing           | Flibble                          |
> |------------------|-----------------------------------|
> | Contradiction ⇒ undecidability | Contradiction ⇒ ill-formed input |
> | Input space includes all valid strings | Input space excludes
> semantically ill-formed programs |

The halting problem itself doesn't have a "contradiction"

The proof uses proof by contradiction, but there is no contradiction in 
the system. (and in fact, it doesn't need to use a proof by 
contradiction, we can also prove it by exhaustive analysis).

The proof just shows that for *ANY* possible machine that is claimed to 
be a Halt Decider, we can construct an input that it will get wrong.

> 
> Damon claims inconsistency where Flibble has already clarified agreement—
> just via a different reasoning path.

Then you need to stop talking about what the classical Halting Problem 
is about.

Either you ARE talking about some opther system, in which case that 
system doesn't say anything about the original system, or

You are talking about the original system, but violating the rules, and 
thus are incorrect.

There is no other case.

> 
> Conclusion:
> -----------
> Richard Damon's critique fails because he measures Flibble’s typed,
> semantic model using classical Turing assumptions. His rebuttals are
> consistent only within a framework Flibble explicitly rejects.
> 
> Thus, Damon’s critiques:
> - Are not wrong *in themselves*,
> - But are irrelevant when applied to a model that redefines the semantic
> rules of the game.

And thus Flibble's model is irrelevant to the classic problem, and can't 
be used to call it "wrong".

> 
> In trying to defend classical computability, Damon inadvertently **commits
> the very category error** that Flibble critiques in the Halting Problem.

And thus Flibble admits to making that same category error when trying 
to apply is reasoning to the Halting Problem. You can't talk about why 
========== REMAINDER OF ARTICLE TRUNCATED ==========