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
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.
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**.
- 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.
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.
Damon misinterprets it as a proposal for unbounded simulation time, rather than an assertion about the necessity of structural analysis.
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.
- It is the **semantic manifestation** of an ill-formed input—an expected behavior when the category boundaries are violated.
This is a reinterpretation of what “failure” means, not a bug.
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.
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.
7. Failing to Address Reframing
-------------------------------
Damon says:
"The halting problem isn't malformed..."
In Turing’s model, it isn’t. But Flibble isn’t working in Turing’s model—
he is reframing the domain entirely to exclude semantically ill-formed constructs. Damon critiques within one framework while Flibble builds another.
Conclusion:
-----------
Richard Damon's responses fail not because of flawed logic, but due to a **category error of interpretation**: he assumes Flibble is arguing within the classical Turing framework when Flibble is explicitly rejecting it in favor of a type- and semantics-based system.
Damon's responses miss the mark because they measure Flibble’s ideas by
the wrong metric. The disagreement isn’t about whether the Halting Problem is undecidable—it’s about *how the problem should be framed* in the first place.
On 5/18/2025 2:17 PM, Mr Flibble wrote:
On Sun, 18 May 2025 14:12:32 -0500, olcott wrote:
They totally lack any understanding of how actual reasoning shows how
these elements actually interrelate with each other. To them false
assumptions are treated as axioms.
Be careful, according to Alan Mackenzie this is libellous because Alan
Mackenzie is a tit.
/Flibble
That is just not the way that libel actually works.
On Sun, 18 May 2025 16:03:13 -0400, Richard Damon wrote:
On 5/18/25 3:58 PM, Mr Flibble wrote:
On Sun, 18 May 2025 15:49:33 -0400, Richard Damon wrote:
On 5/18/25 3:45 PM, Mr Flibble wrote:
On Sun, 18 May 2025 15:19:38 -0400, Richard Damon wrote:
On 5/18/25 1:07 PM, Mr Flibble wrote:
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.
No it isn't. Why? Because the stack overflow a property of the
simulation environment (the fact that the SHD has finite resources)
and NOT a property of the program, P, being analysed per se. P is
NOT halting, it is the SHD that is halting due to the detection of
infinite recursion on the part of P. It is perfectly valid for the
SHD to treat this as NON- HALTING as far as P is concerned.
/Flibble
No, it is a property of the decider. If your "environment" is
inadiquite, it just shows you aren't using a proper environment.
The SHD and the simulation environment are on in the same.
And thus a failure of the environment is a failure of the SHD.
Soemtimes, we will talk about a stack over-flow as not being a
failure,
but also not a success, just an indication that the environment is
insufficent to run this case.
You are just showing you lack of understanding of the system you are
talking about.
You are just showing your lack of understanding of the system I am
talking about.
/Flibble
No, it seems you don't understand what you are talking about, or that
you have just failed to define what you are talking about.
I have seen no system built up from the ground up, only thought about
things to change without defining HOW to effect those changes.
I don't have to create a system to be able to reason about it. You are
just wrong and fractally so.
On Sun, 18 May 2025 18:59:37 -0400, Richard Damon wrote:
On 5/18/25 5:56 PM, Mr Flibble wrote:
On Sun, 18 May 2025 17:29:47 -0400, Richard Damon wrote:
On 5/18/25 4:30 PM, Mr Flibble wrote:
On Sun, 18 May 2025 16:18:04 -0400, Richard Damon wrote:
On 5/18/25 4:09 PM, Mr Flibble wrote:
On Sun, 18 May 2025 16:03:13 -0400, Richard Damon wrote:
On 5/18/25 3:58 PM, Mr Flibble wrote:
On Sun, 18 May 2025 15:49:33 -0400, Richard Damon wrote:
On 5/18/25 3:45 PM, Mr Flibble wrote:The SHD and the simulation environment are on in the same.
On Sun, 18 May 2025 15:19:38 -0400, Richard Damon wrote: >>>>>>>>>>>
On 5/18/25 1:07 PM, Mr Flibble wrote:
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.
No it isn't. Why? Because the stack overflow a property of the >>>>>>>>>>> simulation environment (the fact that the SHD has finite >>>>>>>>>>> resources)
and NOT a property of the program, P, being analysed per se. P >>>>>>>>>>> is NOT halting, it is the SHD that is halting due to the >>>>>>>>>>> detection of infinite recursion on the part of P. It is >>>>>>>>>>> perfectly valid for the SHD to treat this as NON- HALTING as >>>>>>>>>>> far as P is concerned.
/Flibble
No, it is a property of the decider. If your "environment" is >>>>>>>>>> inadiquite, it just shows you aren't using a proper environment. >>>>>>>>>
And thus a failure of the environment is a failure of the SHD.
Not at all, the SHD can abort the simulation if it would result in >>>>>>> stack overflow due to infinite recursion and then return a result >>>>>>> of NON-HALTING.
/Flibble
Yes, *IF* it can show that the simulation WOULD be infinite for that >>>>>> exact input.
Remember, to simulate it, it must be a complete program, that
includes all its defined code.
Thus the "pathological" program, since it is built on a specific
decider, has fixed behavior, as does that specific decider.
SO, if the SHD aborts and returns an answer, the the correct
simulation of the "pathological" program will have its decider do
exactly the same thing.
How the SHD arrives at a halting result is an implementation detail
of the SHD itself: it can do whatever it wants as far as simulation
is concerned.
/Flibble
Right, but it is only correct if the answer is correct.
And nothing about that say anything about getting a stack overflow
violation.
By the basic rules of Compuations, all "answers" must be passed to any >>>> machine that embeds that program, as an out of stack error, if it keep >>>> the embedding program from continuing, isn't an answer and thus a
failure of the decider.
In fact, any system that can actually fail with an out of stack error, >>>> and that is considered to be the result, just fails to be Turing
Complete. We can say the problem is too complicated for that system,
and look at what happens with a bigger system, and if it will even
fail with an unboundedly big system, the operation must be
non-halting, and thus just fail to be a decider.
Thus, the only possible "answer" that an out of stack error can be
would be the non-answer.
No, if infinite recursion is detected then all the SHD needs to do is
return a result of NON-HALTING.
/Flibble
Right, return to whoever calls it. So, if the system crashes, it fails.
If your system catches this out of stack, and winds back to the original
and it returns you are ok, except that if D calls H(D) and H(D) runs out
of stack and rewinds and returns non-halting to D, then D will halt,
making it wrong.
You are making assertions based on no knowledge of implementation details
of the SHD. Foolish.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 34:12:26 |
| Calls: | 10,391 |
| Calls today: | 2 |
| Files: | 14,064 |
| Messages: | 6,417,135 |