On Sat, 19 Apr 2025 15:44:31 -0500, olcott wrote:

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 <[email protected]> writes:

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

Mr Flibble <[email protected]> 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.

OK.

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.

Sorry, you are just showing you don't understand what it means to
DEFINE something.

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.

/Flibble

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.

Sorry, YOU are the one stuck with the fundamental mistake, or is it a
funny mental mistake because you don't understand what you are talking
about.

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

/Flibble

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.

Objective and Subjective Specifications Eric C.R. Hehner Department of Computer Science, University of Toronto

(6) Can Carol correctly answer “no” to this (yes/no) question? https://www.cs.toronto.edu/~hehner/OSS.pdf

Richard Damon found a loophole in the original question.
I inserted (yes/no) to close the loophole.

No, the category error is conflating the decider with the input through self-reference.

/Flibble

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 4/19/25 4:44 PM, olcott wrote:

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 <[email protected]> writes:

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

Mr Flibble <[email protected]> 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.

OK.

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.

Sorry, you are just showing you don't understand what it means to
DEFINE something.

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.

/Flibble

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.

Sorry, YOU are the one stuck with the fundamental mistake, or is it a
funny mental mistake because you don't understand what you are talking
about.

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

/Flibble

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.

And what was done WRONG when we did that?

Now the question: Does the input D halt becomes
self-contradictory for H.

No it doesn't, as the code for D is fully defined because before we
could make D, the code for H had to be fully define.

And thus the actual behavior of the input is a fixed value, based on
that prior decision made in the design of H.

So it is asking a yes/no question where both yes and
no are the wrong answer that is the category error.

No, the right answer exists, it just isn't the answer that H gives.

Since you H returns 0, non-halting, the correct answer to the quesiton
does the program described by the input halt, is Yes,

Now, if you change your H to be H1, a program that returns 1 when given
the D1 built on it, then that D1, a different program than D, will end
up being non-halting, so H1 is wrong for that input.

H(D1) might be correct, as might H1(D), it is just that for ANY Hn you
want to try to make, there is a Dn that Hn(Dn) will give the wrong
answer too.

But Dn still has defined behavior, and isn't itself
"self-contardictory", it is just that Dn is designed to be
Hn-contradictory, something fully allowed by the rules of construction
of Turing Conplete Computation systems.

Objective and Subjective Specifications
Eric C.R. Hehner
Department of Computer Science, University of Toronto

(6) Can Carol correctly answer “no” to this (yes/no) question? https://www.cs.toronto.edu/~hehner/OSS.pdf

Richard Damon found a loophole in the original question.
I inserted (yes/no) to close the loophole.

And the problem is you switch from the actual question of what is the
bahivor of the actual program described by the input, to the subjective question of what can the decider return to be right, which also makes
the decider NOT A PROGRAM, as you are trying to define its behavior by something other than its own code, which isn't valid.

Sorry, you are just showing you don't know what yo are talking about.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 4/19/25 4:57 PM, Mr Flibble wrote:

On Sat, 19 Apr 2025 15:44:31 -0500, olcott wrote:

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 <[email protected]> writes:

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

Mr Flibble <[email protected]> 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.

OK.

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.

Sorry, you are just showing you don't understand what it means to
DEFINE something.

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.

/Flibble

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.

Sorry, YOU are the one stuck with the fundamental mistake, or is it a
funny mental mistake because you don't understand what you are talking >>>> about.

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

/Flibble

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.

Objective and Subjective Specifications Eric C.R. Hehner Department of
Computer Science, University of Toronto

(6) Can Carol correctly answer “no” to this (yes/no) question?
https://www.cs.toronto.edu/~hehner/OSS.pdf

Richard Damon found a loophole in the original question.
I inserted (yes/no) to close the loophole.

No, the category error is conflating the decider with the input through self-reference.

/Flibble

No, the input is clearly defined by what it is. Note that the Olcott presentation is in error, as the input to actually be a program needs to contain its own copy of the decider that it is built on, and not be
"mixed together" in one space. His result *IS* a category error as his
D/DD/DDD isn't a prgram as it is incomplete and when we include that
code into the definition of D/DD/DDD then his arguments about H/HH/HHH
are incorrect as you can't change them "in place" without changing the
input, and his algorith definition can't handle being translated in
memory as show by the HHH/HHH1 difference.

Note, The input in the Linz proof doesn't HAVE a "self-reference", the
program just references (by copying) the decider it is to refute, and it
is given an input that just happens to be a representation of itself,
which is a valid input. The input doesn't "Reference" the
contray-program, it just has a description/copy of it.

Note, Turing Machines don't HAVE "References" as a fundamental
elelement, so can't be self-referenential

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

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

On 4/19/25 4:57 PM, Mr Flibble wrote:

On Sat, 19 Apr 2025 15:44:31 -0500, olcott wrote:

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 <[email protected]> writes:

On Fri, 18 Apr 2025 12:25:36 -0700, Keith Thompson wrote: >>>>>>>>>>> Mr Flibble <[email protected]> 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.

OK.

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.

Sorry, you are just showing you don't understand what it means to >>>>>>> DEFINE something.

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.

/Flibble

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.

Sorry, YOU are the one stuck with the fundamental mistake, or is it
a funny mental mistake because you don't understand what you are
talking about.

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

/Flibble

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.

Objective and Subjective Specifications Eric C.R. Hehner Department of
Computer Science, University of Toronto

(6) Can Carol correctly answer “no” to this (yes/no) question?
https://www.cs.toronto.edu/~hehner/OSS.pdf

Richard Damon found a loophole in the original question.
I inserted (yes/no) to close the loophole.

No, the category error is conflating the decider with the input through
self-reference.

/Flibble

No, the input is clearly defined by what it is. Note that the Olcott presentation is in error, as the input to actually be a program needs to contain its own copy of the decider that it is built on, and not be
"mixed together" in one space. His result *IS* a category error as his D/DD/DDD isn't a prgram as it is incomplete and when we include that
code into the definition of D/DD/DDD then his arguments about H/HH/HHH
are incorrect as you can't change them "in place" without changing the
input, and his algorith definition can't handle being translated in
memory as show by the HHH/HHH1 difference.

Note, The input in the Linz proof doesn't HAVE a "self-reference", the program just references (by copying) the decider it is to refute, and it
is given an input that just happens to be a representation of itself,
which is a valid input. The input doesn't "Reference" the
contray-program, it just has a description/copy of it.

Note, Turing Machines don't HAVE "References" as a fundamental
elelement, so can't be self-referenential

False: the self-referential category error is still extant no matter what representation of the pathological input is passed to the decider.

/Flibble

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 4/19/25 8:07 PM, Mr Flibble wrote:

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

On 4/19/25 4:57 PM, Mr Flibble wrote:

On Sat, 19 Apr 2025 15:44:31 -0500, olcott wrote:

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 <[email protected]> writes:

On Fri, 18 Apr 2025 12:25:36 -0700, Keith Thompson wrote: >>>>>>>>>>>> Mr Flibble <[email protected]> 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.

OK.

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.

Sorry, you are just showing you don't understand what it means to >>>>>>>> DEFINE something.

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.

/Flibble

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.

Sorry, YOU are the one stuck with the fundamental mistake, or is it >>>>>> a funny mental mistake because you don't understand what you are
talking about.

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

/Flibble

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.

Objective and Subjective Specifications Eric C.R. Hehner Department of >>>> Computer Science, University of Toronto

(6) Can Carol correctly answer “no” to this (yes/no) question?
https://www.cs.toronto.edu/~hehner/OSS.pdf

Richard Damon found a loophole in the original question.
I inserted (yes/no) to close the loophole.

No, the category error is conflating the decider with the input through
self-reference.

/Flibble

No, the input is clearly defined by what it is. Note that the Olcott
presentation is in error, as the input to actually be a program needs to
contain its own copy of the decider that it is built on, and not be
"mixed together" in one space. His result *IS* a category error as his
D/DD/DDD isn't a prgram as it is incomplete and when we include that
code into the definition of D/DD/DDD then his arguments about H/HH/HHH
are incorrect as you can't change them "in place" without changing the
input, and his algorith definition can't handle being translated in
memory as show by the HHH/HHH1 difference.

Note, The input in the Linz proof doesn't HAVE a "self-reference", the
program just references (by copying) the decider it is to refute, and it
is given an input that just happens to be a representation of itself,
which is a valid input. The input doesn't "Reference" the
contray-program, it just has a description/copy of it.

Note, Turing Machines don't HAVE "References" as a fundamental
elelement, so can't be self-referenential

False: the self-referential category error is still extant no matter what representation of the pathological input is passed to the decider.

/Flibble

But there is no REFERENCE of any type when you properly recreate the
problem, so there can't be a pathological self-reference.

The category error is in the claimed computation model where the "input"
just fails to be a program.

Sorry, but you are just showing you don't understand what you are
talking about, as you are just accepting a liars system that wasn't
correct in the first place, because he is totally ignorant of what he is talking about, and is just a pathological liar.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

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 <[email protected]> writes:

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

Mr Flibble <[email protected]> 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).
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.

--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)