Re: Flibble’s Leap: Why Behavioral Divergence Implies a Type Distinction in the Halting Problem

On 5/11/2025 12:15 PM, Mr Flibble wrote:

On Sun, 11 May 2025 12:06:40 -0500, olcott wrote:
 

On 5/11/2025 11:59 AM, Mr Flibble wrote:

On Sun, 11 May 2025 11:49:51 -0500, olcott wrote:
>

On 5/11/2025 11:05 AM, Mr Flibble wrote:

On Sun, 11 May 2025 10:56:02 -0500, olcott wrote:
>

On 5/11/2025 10:49 AM, Mr Flibble wrote:

On Sun, 11 May 2025 16:47:09 +0100, Richard Heathfield wrote:
>

On 11/05/2025 16:34, Mr Flibble wrote:

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?

>
Re-read the OP for my answer:
>
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).

>
The directly executed DD() simply halts because HHH has stopped the
infinite recursion that it specifies on its second recursive call.

>
That behaviour is due to a decision you have made, that I disagree
with,
the correct thing to do is to allow infinite recursion to manifest as
stack overflow rather than return an artificial halting result.
>
>

That fails to meet the spec of a termination analyzer.

>
Nevertheless it is impossible to obtain a halting result as the problem
is ill-formed: mapping a halting result of non-halting to the infinite
recursion manifesting due to type mismatch is entirely artificial.
>
/Flibble

>
When a simulating termination analyzer examines the behavior that its
input actually specifies and reports on this, then in the case of every
conventional Halting Problem proof it is correct to reject this input as
non-halting.

 But it would "halt" due to stack overflow if you let the simulation
proceed.
 

That is not what halting means.
Halting means reaching a final halt state and terminating normally.
Neither DDD nor DD correctly emulated by HHH can do that.

The truth is it neither halts nor doesn't halt as the question being asked
is ill-formed.
 /Flibble

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer