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_Richard_Damon=E2=80=99s_Responses_to_Fl?=
 =?UTF-8?Q?ibble?=
Date: Sun, 18 May 2025 15:19:38 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <c54ccda944d953918123fa0244be84b714d088ca@i2pn2.org>
References: <stoWP.617520$lZjd.379219@fx05.ams4>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 18 May 2025 19:25:58 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="923205"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
In-Reply-To: <stoWP.617520$lZjd.379219@fx05.ams4>
X-Spam-Checker-Version: SpamAssassin 4.0.0
Content-Language: en-US

On 5/18/25 1:07 PM, Mr Flibble wrote:
> Analysis of Richard Damon’s Responses to Flibble
> =================================================
> 
> Overview:
> ---------
> Richard Damon's critiques of Flibble's arguments regarding the Halting
> Problem and pathological inputs are based on a classical Turing model.
> However, his rebuttals fundamentally misunderstand or misrepresent the
> core of Flibble’s alternative framework. Below is a breakdown of the key
> errors in Damon’s reasoning.
> 
> 1. Misconstruing the Category Error
> -----------------------------------
> Damon claims:
>> "No, they are not [category errors]."
> 
> Flibble’s argument is not that the input is syntactically invalid, but
> that it is semantically ill-formed due to conflating two distinct roles:
> - The decider
> - The program being analyzed

Which are not "Categories" but "Roles", so it seems you have made a 
category error in defining your categories.

> 
> This is a semantic collapse, akin to Russell’s paradox or typing errors in
> logical frameworks. Damon's rebuttal fails to address the **semantic**
> level, focusing only on syntactic permissibility.

Nope, as the DEFINITION of a Halt Decider is to decide on the 
representation of *ANY* program. Thus, since a decider is a program, a 
decider, or a program based on one is in the category suitable to be 
decided on.

> 
> 2. Ignoring the Model Shift
> ----------------------------
> Damon critiques Flibble’s ideas *from within the classical Turing
> framework*, missing the fact that:
> - Flibble is proposing a **different semantic foundation**.


But to define a "different foundation" you need to do that. The Flibble 
framework doesn't actually define a new framework, but asks about make 
some ill-defined changes.

> - In this new foundation, certain forms of self-reference are *disallowed*
> as a matter of type safety.
> 
> Damon’s refusal to recognize the change in assumptions renders his
> critique logically misaligned.

IF you intend for your statements to be outside the field of Computation 
Theory, you need to make this clear. This is part of the same error that 
Olcott makes.

The problem is that Computation THeory fundamentally allows for the 
formation of this self-referencing (that ability to give an machine as a 
input, and input based on a machine derived from that machine).

There is no way in Computation Theory to disallow this.

THus, to actually implement your ideas, you need a totally new method of 
defining what a program is, and how to build an input.


> 
> 3. Misreading Flibble’s Law
> ----------------------------
> Damon dismisses Flibble’s Law:
>> "Which just isn't true..."
> 
> But Flibble’s Law isn’t about infinite computation—it’s about *recognizing
> the structure* of potentially infinite behavior. It’s a meta-level
> principle, not an operational mandate.

WHich isn't true. Flibble's law tries to establish a "right" for a given 
program, but it can have no rights not established by the theory that it 
is defined under. Since the DEFINITION of a decider is to ALWAYS answer 
in finite time, it is definitionally impossibe to "allow" a machine that 
is a decider to take unbounded time, as Flibble's law tries to do.

That is like saying that 1 equals 2, at least for big values of 1.

> 
> Damon misinterprets it as a proposal for unbounded simulation time, rather
> than an assertion about the necessity of structural analysis.
> 

because your wording doesn't say that. The problem is that compuational 
logic just doesn't allow the limitation of valud questions based on 
whether the question is computable.

THis shows a fundamental misunderstanding of what the field is.

> 4. Stack Overflow as a Semantic Signal
> --------------------------------------
> Damon argues that stack overflow represents a failed computation:
>> "...it just got the wrong answer."
> 
> Flibble’s view is different:
> - A stack overflow (or crash) isn’t failure.

Sure it is. A program that fails to complete and give the correct answer 
has just failed to give an answer.

If you want to define "stack overflow" as an "I don't know" result, 
fine, but first you have to define that this is a "valid" result.

> - It is the **semantic manifestation** of an ill-formed input—an expected
> behavior when the category boundaries are violated.


But there is nothing "ill-formed" about the input.

Again, that is a presupposition you make that isn't true.

> 
> This is a reinterpretation of what “failure” means, not a bug.

And "redefinition" isn't an allowed operation.

You can start over and make a new system, but that means you NEED to 
start over.

This is just a repeating of Olcott's misunderstanding of how logic works

> 
> 5. Misidentifying Recursion Criticism
> -------------------------------------
> Damon says:
>> "Just the presence of recursion isn't the problem."
> 
> This is a straw man. Flibble does *not* claim recursion is inherently
> invalid—only that **self-referential decider/input recursion** creates
> type-theoretic inconsistency. Damon’s rebuttal avoids the specific case
> Flibble addresses.
> 

But Flibble can't define where the error is. Note, that in the actual 
theory, the program at the input has definite behavior because it is 
built from a specific decider, there is no ambiquity on the correct answer.

Only by adoptitng Olcott's error of makeing an input that isn't actually 
a program, and claiming that doing so is correct, does the pathology in 
the form adderess by Flibble appear. SInce the original theory already 
calls the Olcott input a category error because it isn't an actual 
program, but a template that can't ever actually be run (as it has 
missing code) but only be simulated/decider by a decider with a specific 
name (an attribute that isn't supposed to have import in the theory).

Thus, the Flibble theory is based on the assumption of allowing a 
category error to define something to be a category error.

Yes, the Olcott DDD is a category error, not because it calls the 
decider HHH, but because it assumes it can call it as an external, a 
concept that doesn't exist in the theory. When the input is made into a 
full program, it still foils the input, when it is the machine that it 
was built on, but

> 6. Downplaying the Role of SHDs
> -------------------------------
> Damon concedes:
>> "Yes, partial deciders have some uses..."
> 
> But Flibble’s point is stronger:
> - SHDs are useful not as general solvers, but as **structural recognizers
> of malformed input**.
> - Their “failure” (e.g., crashing on pathological input) is
> **informative**, not defective.
> 
> Damon reduces SHDs to weak approximators, missing Flibble’s proposed
> semantic role.

No, I do not. I point out that they have *SOME* uses.

They do not fulfill the original desire for a Halt Decider, which was to 
make all logic computable with mathematics, allowing any problem to be 
========== REMAINDER OF ARTICLE TRUNCATED ==========