On Sun, 11 May 2025 16:47:09 +0100, Richard Heathfield wrote:Which is full of errors as I have pointed out.
On 11/05/2025 16:34, Mr Flibble wrote:Re-read the OP for my answer:On Sun, 11 May 2025 16:25:14 +0100, Richard Heathfield wrote:>
>For a question to be semantically incorrect, it takes more than just>
you and your allies to be unhappy with it.
For a question to be semantically correct, it takes more than just you
and your allies to be happy with it.
Indeed. It has to have meaning. It does. That meaning has to be
understood by sufficiently intelligent people. It is.
>
You don't like the question. I get that. I don't know /why/ you don't
like it, because all your explanations to date have been complete
expletive deleted. For a Usenet article to be semantically correct, it
helps if your readers can understand what the <exp. del.> you're talking
about.
>
What I get from your stand is that you agree with olcott that a
'pathological' input halts... no, never halts... well, you can't decide
between you, but you're agreed that it's definitely decidable, right?
Flibble’s Leap: Why Behavioral Divergence Implies a Type Distinction in
the Halting Problem
===========================================================================================
Summary
-------
Flibble argues that the Halting Problem's undecidability proof is built on
a category (type) error: it assumes a program and its own representation
(as a finite string) are interchangeable. This assumption fails under
simulating deciders, revealing a type distinction through behavioral
divergence. As such, all deciders must respect this boundary, and
diagonalization becomes ill-formed. This reframing dissolves the paradox
by making the Halting Problem itself an ill-posed question.
1. Operational Evidence of Type Distinction
-------------------------------------------
- When a program (e.g., `DD()`) is passed to a simulating halt decider
(`HHH`), it leads to infinite recursion.
- This behavior differs from direct execution (e.g., a crash due to a
stack overflow).
- This divergence shows that the program (as code) and its representation
(as data) are operationally distinct.
- Therefore, treating them as the same "type" (as Turing's proof does)
leads to inconsistency.
2. Generalization to All Deciders
---------------------------------
- If simulation reveals this type mismatch, then no valid decider can rely
on conflating program and representation.
- Diagonalization (e.g., defining D(x) = if H(x,x) then loop else halt)
necessarily crosses the type boundary.
- The contradiction in the Halting Problem arises from this type error,
not from inherent undecidability.
- Hence, the Halting Problem is ill-defined for self-referential input.
3. Comparisons to Other Formal Systems
--------------------------------------
- In type-theoretic systems (like Coq or Agda), such self-reference is
disallowed:
- Programs must be well-typed.
- Self-referential constructs like `H(x, x)` are unrepresentable if they
would lead to paradox.
- In category theory, morphisms must respect domain/codomain boundaries:
- Reflexive constructions require stratification to avoid logical
inconsistency.
4. Conclusion
-------------
- The Halting Problem depends on self-reference and diagonalization.
- If these constructs are blocked due to type/category errors, the proof
breaks down.
- Thus, the Halting Problem isn’t undecidable—it’s malformed when it
crosses type boundaries.
- This is not a refutation of Turing, but a reformulation of the problem
under more disciplined typing rules.
This model mirrors how Russell’s Paradox was avoided in modern logic: not
by solving the contradiction, but by redefining the terms that made the
contradiction possible.
| Date | Sujet | # | Auteur | |
| 14 Jun 26 |  … |
Les messages affichés proviennent d'usenet.