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

On 5/11/25 8:41 PM, olcott wrote:

On 5/11/2025 6:45 PM, Richard Damon wrote:

On 5/11/25 7:14 PM, olcott wrote:

On 5/11/2025 6:05 PM, Keith Thompson wrote:

Mr Flibble <flibble@red-dwarf.jmc.corp> writes:

On Sun, 11 May 2025 18:15:47 +0100, Richard Heathfield wrote:
>

On 11/05/2025 17:59, Mr Flibble wrote:

it is impossible to obtain a halting result

>
>
That sure looks like a concession that it's impossible to devise an
algorithm that will produce a halting result.
>
Well done. We got you there in the end.

>
No. The reason why it is impossible to obtain a halting result for
pathological input is not the reason proposed by Turing (i.e. self-
referential diagonalization), it is impossible to obtain a halting result
for pathological input because the self-referential conflation of decider
and input is a category error that prevents us from performing
diagonalization.

>
Is it possible to determine whether a given input is "pathological" or not?
>

To usefully advance research in this area pathological input needs to be
excluded from the set of programs that can be analysed by a decider.

>
Can this exclusion be performed reliably and consistently?
>

>
That is a good question. The answer is definitely
yes. When HHH emulates DDD it only needs to see
that DDD is calling itself with no conditional branch
instructions inbetween.
>
Whether a function computed by a Turing machine can
do this is a different question.
>

>
So, try to do it.
>

 No need to. DDD emulated by HHH according to the
rules of the computational language that DD is
encoded within already proves that the HP
"impossible" input specifies a non-halting
sequence of configurations.

So, you are admitting you can't.
The rules of computation language say that HHH must be a funciton of *OMLY* it explict input, and thus for HHH to actually emulate DDD, then the HHH that DDD calls must be part of the input (and part of DDD).
Since none of your HHH's that give an answer actually DO a correct emulation, and that is the only kind really accept by computational language (without the EXPLICT partial modifier), your statement is just a NULL statement that doesn't say anything.
Since the CORRECT emulation of DDD by the rules you require (minus the invalid restriction that it be by a machine that can't do it) shows that DDD WILL halt for any of your HHH that return an answer, so every HHH(DDD) that returns 0 is just wrong.

 This by itself is much more progress than anyone
else has ever made on the halting problem.
 

Nope, as it is just lies.

To the best of my recollection
Mike has already agreed that the outermost HHH
can dig into the details of all of the levels
of recursive simulation to get the details that
it currently uses. All of these details are
merely data to this outermost HHH.
 This is analogous to a master UTM examining
all of its own tape, even those portions that
are allocated to slave UTMs.
 

Which doesn't help, since you don't actually have any UTMs. Remember, BY DEFINITON, a UTM just reproduces the behavior of the machine described by its input. Not report what it does, but to DO it. So, BY DEFINITION, a UTM given a non-halting input, can not halt. And thus, a UTM can't be used as a decider if the input can be a non-halting program, and thus worthless as a Halt Decider.
Remember, one way of stateing the requirements of a Halt Decider is that H(D) returns "Halting" if UTM(D) will halt, and "Non-Halting" if UTM(D) will not halt. THis does not mean change D to use UTM, it mean the exact D that was given to H is given to UTM, and NONE of the code used by it changes.
The fact that you model can't seem to handle that just shows your model is incorrect.
And yes, the outer Decider can try to understand the contents and meaning of the tape of the machine it is emulating, but first you have to show how it recognizes that machine, when you don't put non-Turing Complete limitations on your programs like you do. This means that DDD can have its own copy of HHH and thus HHH can't use its address as the test, and DDD needs to be able to make a copy of its input at another portion of the tape (new memory addresses in your system).
Try to allow that and see what you get. The fact that your system fails to be Turing Complete just proves that it can't be the equivalent of the systems in the proof.