Hi!
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).
A simulating halt decider of the unpartial type *with infinite resources* solves the halting problem as corrected to exclude the self referencial category error.
Turing’s statement of the problem included logically invalid inputs. Once we correct the domain to disallow self-reference, the rest is decidable.
/Flibble
Does your new definition handle the busy-beaver problem? (Which could be solved if we actually had halt deciders)
On Fri, 18 Apr 2025 10:30:05 -0400, Richard Damon wrote:
Does your new definition handle the busy-beaver problem? (Which could be
solved if we actually had halt deciders)
Yes, because:
* The Busy Beaver machines being considered “well-formed” (i.e., not pathological).
* The ability to detect non-halting via repeated state (which is valid for Turing machines with bounded state spaces).\
* Granting infinite resources for simulation.
/Flibble
On 4/18/25 10:50 AM, Mr Flibble wrote:
* The ability to detect non-halting via repeated state (which is valid
for Turing machines with bounded state spaces).\
But it isn't, as Turing Machines have an unbounded 'state' space with
their tape. They have finite states of the machine, but unbounded state
of the tape, so infinite loops using that tape can occur and never
repeat "state".
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.
OK.
Do you have a *rigorous* definition of "pathological input"?
Is there an algorithm to determine whether a given input is
"pathological" or not?
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.
On Fri, 18 Apr 2025 12:32:41 -0700, 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.
OK.
Do you have a *rigorous* definition of "pathological input"?
Is there an algorithm to determine whether a given input is
"pathological" or not?
In the general case pathological input is not computable as it is a category/type error (ergo not logically sound) so there is no algorithm
that can detect it. Specific forms of it can however be detected by a Simulating Halt Decider given certain constraints - see Mr Olcott for details.
/Flibble
Another point: The well known proof that the Halting Problem is
not solvable works by assuming that a halt decider exists and then
creating *one* input, based on the code of the decider, on which
the decider cannot give a correct answer. You can call that input "self-referential to the decider".
--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
void Void(void) { Void(); } /* The recursive call of the void */
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.
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.
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.
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.
On 4/18/25 11:52 PM, olcott wrote:
On 4/18/2025 2:32 PM, Keith Thompson wrote:Examples are not definitions.
Mr Flibble <flibble@red-dwarf.jmc.corp> writes:int DD()
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.
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 Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
Patterns isomorphic to the above when simulated by HHH.
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.
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:Examples are not definitions.
Mr Flibble <flibble@red-dwarf.jmc.corp> writes:int DD()
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.
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 Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
Patterns isomorphic to the above when simulated by HHH.
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
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:Examples are not definitions.
Mr Flibble <flibble@red-dwarf.jmc.corp> writes:int DD()
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.
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 Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
Patterns isomorphic to the above when simulated by HHH.
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.
On 4/19/25 8:05 AM, Mr Flibble wrote:
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.
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:Examples are not definitions.
Mr Flibble <flibble@red-dwarf.jmc.corp> writes:int DD()
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.
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 Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
Patterns isomorphic to the above when simulated by HHH.
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
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (3 / 13) |
| Uptime: | 06:11:38 |
| Calls: | 10,388 |
| Calls today: | 3 |
| Files: | 14,061 |
| Messages: | 6,416,808 |
| Posted today: | 1 |