Re: The conventional HP is a Category Error

On 4/22/25 3:34 PM, olcott wrote:

On 4/22/2025 8:02 AM, joes wrote:

Am Sat, 19 Apr 2025 15:44:31 -0500 schrieb olcott:

On 4/19/2025 1:06 PM, Mr Flibble wrote:

On Sat, 19 Apr 2025 13:34:40 -0400, Richard Damon wrote:

On 4/19/25 8:05 AM, Mr Flibble wrote:

On Sat, 19 Apr 2025 07:55:55 -0400, Richard Damon wrote:

On 4/18/25 11:52 PM, olcott wrote:

On 4/18/2025 2:32 PM, Keith Thompson wrote:

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

On Fri, 18 Apr 2025 12:25:36 -0700, Keith Thompson wrote:

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

>

I, aka Mr Flibble, have created a new computer science term,
the "Unpartial Halt Decider".  It is a Halt Decider over the
domain of all program-input pairs excluding pathological input
(a manifestation of the self referencial category error).

[...]
>
Do you have a rigorous definition of "pathological input"?
Is there an algorithm to determine whether a given input is
"pathological" or not?
I could define an is_prime() function like this:
>
        bool is_prime(int n) {
            return n >= 3 && n % 2 == 1;
            // returns true for odd numbers >= 3, false
            for all others
        }
I'll just say that odd numbers that are not prime are
pathological input, so I don't have to deal with them.

>
Pathological input: Self-referencial to the decider.

>
Do you have a *rigorous* definition of "pathological input"?
Is there an algorithm to determine whether a given input is
"pathological" or not?
>

int DD()
{
      int Halt_Status = HHH(DD);
      if (Halt_Status)
        HERE: goto HERE;
      return Halt_Status;
}
Patterns isomorphic to the above when simulated by HHH.
>

Examples are not definitions.
And the problem is that the above example is itself a category error
for the problem, as the DD provided above isn't a complete program,
as it doesn't include the code for HHH as required, and when you
include Halt7.c as part of the input, your HHH isn't a seperate
program of its own, and thus doesn't have a Turing Complete range of
inputs it can accept.

>
Ah, the fundamental mistake you have been making all this time,
Damon!
The self-referencial category error doesn't magically disappear by
providing source code rather than a run-time function address to the
decider; you are simply transforming the same input without affecting
the result.

>
And WHAT is the category error?  You stil can't show the difference in
CATEGORY between what is allowed and what isn't, and in fact, you
can't even precisely define what is and isn't allowed.
Now, you also run into the issue that the "Olcott System" begins with
an actual category error as we do not have the required two seperate
programs of the "Decider" and the "Program to be decided on" given via
representation as the input, as what you want to call that program to
be decided isn't one without including the code of the decider it is
using,
and when you do include it, the arguments about no version of the
decider being able to succeed is improper as it must always be that
exact program that we started with, and thus it just FAILS to do a
correct simulation, while a correct simulation of this exact input
(which includes the ORIGINAL decider) will halt.

>
The category error is extant over the domain of pathological inputs, no
matter what form those inputs take.

>
The category error in the halting problem proof is to define an input D
that is able to actually do the opposite of whatever value that H
reports.
Now the question: Does the input D halt becomes self-contradictory for
H.
So it is asking a yes/no question where both yes and no are the wrong
answer that is the category error.

 

No, D either halts or doesn't depending on H (which must return a value).

 That is as stupid as saying that this sentence must
be true or false: "This sentence is not true".

Do you not understand that H(D) must have defined behavor if H is actually a program, and thus D is allowed, and able, to act contray to it.
Your bad analogy just fails to show the proper equivalence, because you just don't understand what truth actually is.

 

And H can't turn around and return the other value, as that changes D.
There are other deciders that get D right, but the same construction
works on them: every supposed decider has a counterexample, none decides
every input.
>

 I have proven that the directly executed DD and DD
emulated by HHH according to the semantics of the
x86 language have a different set of state changes
many hundreds of times for several years.

No you haven't. You have claimed it, and the claim has been refuted, and you have never overcome the refutation.

 HHH is not allowed to report on anything besides
the behavior of DD emulated by HHH including HHH
emulating itself emulating DD.

Sure it is, WHere do you get that. It CAN'T report on something it can't compute, but that doesn't mean it can't be requried to do so to be correct.
That just shows the problem is uncomputable.

 a function is computable if there exists an algorithm
that can do the job of the function, i.e. given an input
of the function domain it can return the corresponding output.
https://en.wikipedia.org/wiki/Computable_function

Right, and the fact that you can't make a function that correctly answers the actual Halting Quesstion means it isn't a computable function.
What is so hard about that?

 Outputs are forced to correspond to inputs when finite string
transformation rules are applied to inputs to derive outputs.
 

The output will be what the machine computes.
That doesn't mean theya are right, that is determined by the specification.
Something you don't seem to understand, as that requires understand what it means to be TRUE or correct.
You just don't understand how RULES work.