Hi!

I have an idea for a signaling simulating halt decider that forks the
simulation into two branches if the input calls the halt decider as
per [Strachey 1965]'s "Impossible Program":

void P(void (*x)())
{ if (H(x, x))
infinite_loop: goto infinite_loop;
return;
}

int main()
{ std::cout << "Input halts: " << H(P, P) << std::endl;
}

When the simulator detects the call to H in P it forks the simulation
into a non-halting branch (returning 0 to P) and a halting branch
(returning 1 to P) and continues the simulation of these two branches
in parallel.

If the non-halting branch is determined to halt AND the halting branch
is determined to not halt then pathology is detected and reported via
a sNaP (signaling Not a Program) signal (analogous to IEEE 754's
sNaN (signaling Not a Number) signal)

If EITHER branch is determined to be correctly decided then that will
be the decision of the halting decider.

Crucially this scheme will handle (and correctly decide) the
following case whereby the result of H is discarded by the input:

void Px(void (*x)())
{ (void) H(x, x);
return;
}

Obviously my idea necessitates extending the definition of a halt
decider:

1) Decider decision is HALTS if input halts.
2) Decider decision is NON-HALTING if input does not halt.
3) Decider rejects pathological input as invalid by signaling sNaP.

Thoughts? I am probably missing something obvious as my idea
appears to refute [Strachey 1965] and associated HP proofs which
great minds have mulled over for decades.

This refutation of the existing Halting Problem proofs has been confirmed
by ChatGPT AI which recognises that (3) above is a category error:-

https://twitter.com/i42Software/status/1609626194273525760

The discovery of this category error is a unique achievement made by Mr
Flibble alone and should set a new direction for Halting Problem related
theory and research for many decades to come especially with quantum
computers and such making a simulation-based approach achievable within
the lifetime of the observable universe.

/Flibble

On 2/3/23 11:59 AM, Mr Flibble wrote:
> Hi!
>
> I have an idea for a signaling simulating halt decider that forks the
> simulation into two branches if the input calls the halt decider as
> per [Strachey 1965]'s "Impossible Program":
>
> void P(void (*x)())
> {
> if (H(x, x))
> infinite_loop: goto infinite_loop;
> return;
> }
>
> int main()
> {
> std::cout << "Input halts: " << H(P, P) << std::endl;
> }
>
> When the simulator detects the call to H in P it forks the simulation
> into a non-halting branch (returning 0 to P) and a halting branch
> (returning 1 to P) and continues the simulation of these two branches
> in parallel.
>
> If the non-halting branch is determined to halt AND the halting branch
> is determined to not halt then pathology is detected and reported via
> a sNaP (signaling Not a Program) signal (analogous to IEEE 754's
> sNaN (signaling Not a Number) signal)
>
> If EITHER branch is determined to be correctly decided then that will
> be the decision of the halting decider.
>
> Crucially this scheme will handle (and correctly decide) the
> following case whereby the result of H is discarded by the input:
>
> void Px(void (*x)())
> {
> (void) H(x, x);
> return;
> }
>
> Obviously my idea necessitates extending the definition of a halt
> decider:
>
> 1) Decider decision is HALTS if input halts.
> 2) Decider decision is NON-HALTING if input does not halt.
> 3) Decider rejects pathological input as invalid by signaling sNaP.
>
> Thoughts? I am probably missing something obvious as my idea
> appears to refute [Strachey 1965] and associated HP proofs which
> great minds have mulled over for decades.
>
> This refutation of the existing Halting Problem proofs has been confirmed
> by ChatGPT AI which recognises that (3) above is a category error:-
>
> https://twitter.com/i42Software/status/1609626194273525760
>
> The discovery of this category error is a unique achievement made by Mr
> Flibble alone and should set a new direction for Halting Problem related
> theory and research for many decades to come especially with quantum
> computers and such making a simulation-based approach achievable within
> the lifetime of the observable universe.
>
> /Flibble

Ultimately, the problem is that your answer "3" is poorly defined.

The issue is what should the Halt Decider give for an input that itself
signals sNaP?

What happens if a program "traps" the sNaP adn does something with it?

A fundamental part of the problem is that the Halt Decider needs to be
nothing more than a "normal" program in the system, without special
"powers", otherwise its domain of inputs isn't "Complete", so this makes
your definition not fit the classic definiton of a computation theory
"program".

A Part of this issue, it that the program to decide on really needs to
be in an isolated sandbox to the decider, so the presence of the decider
doesn't limit what programs it can be given. You H, BY DEFINITON, can't
be given a totally "arbitrary" input program, as you are defining the
contents of some of the address space.

Once you do this, the "self-reference" your system is based on goes
away. and you end up with the problem that H needs to be able to
recognize that the input contains a machine that is the "equivalent" of
itself, which might not be an identical representation. In fact, one key
issue is that it can be shown that a given "program" can have an
infinite number of identically acting variations in representation, so
the problem of detecting a copy of somthing equivalent to yourself is
not computable.

On Fri, 03 Feb 2023 12:18:38 -0500, Richard Damon wrote:

> On 2/3/23 11:59 AM, Mr Flibble wrote:
>> Hi!
>>
>> I have an idea for a signaling simulating halt decider that forks the
>> simulation into two branches if the input calls the halt decider as per
>> [Strachey 1965]'s "Impossible Program":
>>
>> void P(void (*x)())
>> {
>> if (H(x, x))
>> infinite_loop: goto infinite_loop;
>> return;
>> }
>>
>> int main()
>> {
>> std::cout << "Input halts: " << H(P, P) << std::endl;
>> }
>>
>> When the simulator detects the call to H in P it forks the simulation
>> into a non-halting branch (returning 0 to P) and a halting branch
>> (returning 1 to P) and continues the simulation of these two branches
>> in parallel.
>>
>> If the non-halting branch is determined to halt AND the halting branch
>> is determined to not halt then pathology is detected and reported via a
>> sNaP (signaling Not a Program) signal (analogous to IEEE 754's sNaN
>> (signaling Not a Number) signal)
>>
>> If EITHER branch is determined to be correctly decided then that will
>> be the decision of the halting decider.
>>
>> Crucially this scheme will handle (and correctly decide) the following
>> case whereby the result of H is discarded by the input:
>>
>> void Px(void (*x)())
>> {
>> (void) H(x, x);
>> return;
>> }
>>
>> Obviously my idea necessitates extending the definition of a halt
>> decider:
>>
>> 1) Decider decision is HALTS if input halts.
>> 2) Decider decision is NON-HALTING if input does not halt.
>> 3) Decider rejects pathological input as invalid by signaling sNaP.
>>
>> Thoughts? I am probably missing something obvious as my idea appears
>> to refute [Strachey 1965] and associated HP proofs which great minds
>> have mulled over for decades.
>>
>> This refutation of the existing Halting Problem proofs has been
>> confirmed by ChatGPT AI which recognises that (3) above is a category
>> error:-
>>
>> https://twitter.com/i42Software/status/1609626194273525760
>>
>> The discovery of this category error is a unique achievement made by Mr
>> Flibble alone and should set a new direction for Halting Problem
>> related theory and research for many decades to come especially with
>> quantum computers and such making a simulation-based approach
>> achievable within the lifetime of the observable universe.
>>
>> /Flibble
>
> Ultimately, the problem is that your answer "3" is poorly defined.
>
> The issue is what should the Halt Decider give for an input that itself
> signals sNaP?
>
> What happens if a program "traps" the sNaP adn does something with it?
>
> A fundamental part of the problem is that the Halt Decider needs to be
> nothing more than a "normal" program in the system, without special
> "powers", otherwise its domain of inputs isn't "Complete", so this makes
> your definition not fit the classic definiton of a computation theory
> "program".
>
> A Part of this issue, it that the program to decide on really needs to
> be in an isolated sandbox to the decider, so the presence of the decider
> doesn't limit what programs it can be given. You H, BY DEFINITON, can't
> be given a totally "arbitrary" input program, as you are defining the
> contents of some of the address space.
>
> Once you do this, the "self-reference" your system is based on goes
> away. and you end up with the problem that H needs to be able to
> recognize that the input contains a machine that is the "equivalent" of
> itself, which might not be an identical representation. In fact, one key
> issue is that it can be shown that a given "program" can have an
> infinite number of identically acting variations in representation, so
> the problem of detecting a copy of somthing equivalent to yourself is
> not computable.

The category error that I alone have identified prevents the scheme you
describe from being possible: the self reference cannot be broken with a
sandbox given the definition of the Halting Problem.

/Flibble

On 2/3/23 1:00 PM, Mr Flibble wrote:
> On Fri, 03 Feb 2023 12:18:38 -0500, Richard Damon wrote:
>
>> On 2/3/23 11:59 AM, Mr Flibble wrote:
>>> Hi!
>>>
>>> I have an idea for a signaling simulating halt decider that forks the
>>> simulation into two branches if the input calls the halt decider as per
>>> [Strachey 1965]'s "Impossible Program":
>>>
>>> void P(void (*x)())
>>> {
>>> if (H(x, x))
>>> infinite_loop: goto infinite_loop;
>>> return;
>>> }
>>>
>>> int main()
>>> {
>>> std::cout << "Input halts: " << H(P, P) << std::endl;
>>> }
>>>
>>> When the simulator detects the call to H in P it forks the simulation
>>> into a non-halting branch (returning 0 to P) and a halting branch
>>> (returning 1 to P) and continues the simulation of these two branches
>>> in parallel.
>>>
>>> If the non-halting branch is determined to halt AND the halting branch
>>> is determined to not halt then pathology is detected and reported via a
>>> sNaP (signaling Not a Program) signal (analogous to IEEE 754's sNaN
>>> (signaling Not a Number) signal)
>>>
>>> If EITHER branch is determined to be correctly decided then that will
>>> be the decision of the halting decider.
>>>
>>> Crucially this scheme will handle (and correctly decide) the following
>>> case whereby the result of H is discarded by the input:
>>>
>>> void Px(void (*x)())
>>> {
>>> (void) H(x, x);
>>> return;
>>> }
>>>
>>> Obviously my idea necessitates extending the definition of a halt
>>> decider:
>>>
>>> 1) Decider decision is HALTS if input halts.
>>> 2) Decider decision is NON-HALTING if input does not halt.
>>> 3) Decider rejects pathological input as invalid by signaling sNaP.
>>>
>>> Thoughts? I am probably missing something obvious as my idea appears
>>> to refute [Strachey 1965] and associated HP proofs which great minds
>>> have mulled over for decades.
>>>
>>> This refutation of the existing Halting Problem proofs has been
>>> confirmed by ChatGPT AI which recognises that (3) above is a category
>>> error:-
>>>
>>> https://twitter.com/i42Software/status/1609626194273525760
>>>
>>> The discovery of this category error is a unique achievement made by Mr
>>> Flibble alone and should set a new direction for Halting Problem
>>> related theory and research for many decades to come especially with
>>> quantum computers and such making a simulation-based approach
>>> achievable within the lifetime of the observable universe.
>>>
>>> /Flibble
>>
>> Ultimately, the problem is that your answer "3" is poorly defined.
>>
>> The issue is what should the Halt Decider give for an input that itself
>> signals sNaP?
>>
>> What happens if a program "traps" the sNaP adn does something with it?
>>
>> A fundamental part of the problem is that the Halt Decider needs to be
>> nothing more than a "normal" program in the system, without special
>> "powers", otherwise its domain of inputs isn't "Complete", so this makes
>> your definition not fit the classic definiton of a computation theory
>> "program".
>>
>> A Part of this issue, it that the program to decide on really needs to
>> be in an isolated sandbox to the decider, so the presence of the decider
>> doesn't limit what programs it can be given. You H, BY DEFINITON, can't
>> be given a totally "arbitrary" input program, as you are defining the
>> contents of some of the address space.
>>
>> Once you do this, the "self-reference" your system is based on goes
>> away. and you end up with the problem that H needs to be able to
>> recognize that the input contains a machine that is the "equivalent" of
>> itself, which might not be an identical representation. In fact, one key
>> issue is that it can be shown that a given "program" can have an
>> infinite number of identically acting variations in representation, so
>> the problem of detecting a copy of somthing equivalent to yourself is
>> not computable.
>
> The category error that I alone have identified prevents the scheme you
> describe from being possible: the self reference cannot be broken with a
> sandbox given the definition of the Halting Problem.
>
> /Flibble

What is the "Category Error"

P is a program that takes an input, and generates a result.

If H is a Halt Decider, it is supposed to be able to take in ANY
program, and answer what it will do, thus to be correct it needs to be
able to correctly answer about this P, even if it has been built on a
copy of this H, so it is able to answer contradictory.

The only "Category Error" is thinking that H can be given an "arbitrary
program" as required.

Removing the "Sandbox", all you are doing is beginning with an admission
that you can't actually handle "Any Program".

In fact, this form of a system doesn't even really have a "tape" for a
Turing Machine, and there is no (at least simple) way to modify it to
have one, as without the idea of independent address spaces for Decider,
Input machine, and input we can't actually fully express the problem.

The issue is that P needs to be given a "copy" of itself that it can
"duplicate", and H is allowed (and in fact almost certainly would want
to) write to, but there is no way to have two independent copies of the
code of P as, without a "sandbox", since P is at a specific address,
that copy must be at that address in memory, and thus the two copies
overlap and aren't independent.

On Fri, 03 Feb 2023 15:52:56 -0500, Richard Damon wrote:

> On 2/3/23 1:00 PM, Mr Flibble wrote:
>> On Fri, 03 Feb 2023 12:18:38 -0500, Richard Damon wrote:
>>
>>> On 2/3/23 11:59 AM, Mr Flibble wrote:
>>>> Hi!
>>>>
>>>> I have an idea for a signaling simulating halt decider that forks the
>>>> simulation into two branches if the input calls the halt decider as
>>>> per [Strachey 1965]'s "Impossible Program":
>>>>
>>>> void P(void (*x)())
>>>> {
>>>> if (H(x, x))
>>>> infinite_loop: goto infinite_loop;
>>>> return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> std::cout << "Input halts: " << H(P, P) << std::endl;
>>>> }
>>>>
>>>> When the simulator detects the call to H in P it forks the simulation
>>>> into a non-halting branch (returning 0 to P) and a halting branch
>>>> (returning 1 to P) and continues the simulation of these two branches
>>>> in parallel.
>>>>
>>>> If the non-halting branch is determined to halt AND the halting
>>>> branch is determined to not halt then pathology is detected and
>>>> reported via a sNaP (signaling Not a Program) signal (analogous to
>>>> IEEE 754's sNaN (signaling Not a Number) signal)
>>>>
>>>> If EITHER branch is determined to be correctly decided then that will
>>>> be the decision of the halting decider.
>>>>
>>>> Crucially this scheme will handle (and correctly decide) the
>>>> following case whereby the result of H is discarded by the input:
>>>>
>>>> void Px(void (*x)())
>>>> {
>>>> (void) H(x, x);
>>>> return;
>>>> }
>>>>
>>>> Obviously my idea necessitates extending the definition of a halt
>>>> decider:
>>>>
>>>> 1) Decider decision is HALTS if input halts.
>>>> 2) Decider decision is NON-HALTING if input does not halt.
>>>> 3) Decider rejects pathological input as invalid by signaling sNaP.
>>>>
>>>> Thoughts? I am probably missing something obvious as my idea appears
>>>> to refute [Strachey 1965] and associated HP proofs which great minds
>>>> have mulled over for decades.
>>>>
>>>> This refutation of the existing Halting Problem proofs has been
>>>> confirmed by ChatGPT AI which recognises that (3) above is a category
>>>> error:-
>>>>
>>>> https://twitter.com/i42Software/status/1609626194273525760
>>>>
>>>> The discovery of this category error is a unique achievement made by
>>>> Mr Flibble alone and should set a new direction for Halting Problem
>>>> related theory and research for many decades to come especially with
>>>> quantum computers and such making a simulation-based approach
>>>> achievable within the lifetime of the observable universe.
>>>>
>>>> /Flibble
>>>
>>> Ultimately, the problem is that your answer "3" is poorly defined.
>>>
>>> The issue is what should the Halt Decider give for an input that
>>> itself signals sNaP?
>>>
>>> What happens if a program "traps" the sNaP adn does something with it?
>>>
>>> A fundamental part of the problem is that the Halt Decider needs to be
>>> nothing more than a "normal" program in the system, without special
>>> "powers", otherwise its domain of inputs isn't "Complete", so this
>>> makes your definition not fit the classic definiton of a computation
>>> theory "program".
>>>
>>> A Part of this issue, it that the program to decide on really needs to
>>> be in an isolated sandbox to the decider, so the presence of the
>>> decider doesn't limit what programs it can be given. You H, BY
>>> DEFINITON, can't be given a totally "arbitrary" input program, as you
>>> are defining the contents of some of the address space.
>>>
>>> Once you do this, the "self-reference" your system is based on goes
>>> away. and you end up with the problem that H needs to be able to
>>> recognize that the input contains a machine that is the "equivalent"
>>> of itself, which might not be an identical representation. In fact,
>>> one key issue is that it can be shown that a given "program" can have
>>> an infinite number of identically acting variations in representation,
>>> so the problem of detecting a copy of somthing equivalent to yourself
>>> is not computable.
>>
>> The category error that I alone have identified prevents the scheme you
>> describe from being possible: the self reference cannot be broken with
>> a sandbox given the definition of the Halting Problem.
>>
>> /Flibble
>
> What is the "Category Error"
>
> P is a program that takes an input, and generates a result.
>
> If H is a Halt Decider, it is supposed to be able to take in ANY
> program, and answer what it will do, thus to be correct it needs to be
> able to correctly answer about this P, even if it has been built on a
> copy of this H, so it is able to answer contradictory.
>
> The only "Category Error" is thinking that H can be given an "arbitrary
> program" as required.
>
> Removing the "Sandbox", all you are doing is beginning with an admission
> that you can't actually handle "Any Program".
>
> In fact, this form of a system doesn't even really have a "tape" for a
> Turing Machine, and there is no (at least simple) way to modify it to
> have one, as without the idea of independent address spaces for Decider,
> Input machine, and input we can't actually fully express the problem.
>
> The issue is that P needs to be given a "copy" of itself that it can
> "duplicate", and H is allowed (and in fact almost certainly would want
> to) write to, but there is no way to have two independent copies of the
> code of P as, without a "sandbox", since P is at a specific address,
> that copy must be at that address in memory, and thus the two copies
> overlap and aren't independent.

A category error occurs when we attempt to predicate upon a non-existent
relationship between two orthogonal categories: in this case the two
caregories are the halting decider and the program/input pair being
decided upon. This category error manifests due to the self referencing
pathology of the current Halting Problem definition (and proofs predicated
upon that definition).

/Flibble

On 2/3/23 4:44 PM, Mr Flibble wrote:
> On Fri, 03 Feb 2023 15:52:56 -0500, Richard Damon wrote:
>
>> On 2/3/23 1:00 PM, Mr Flibble wrote:
>>> On Fri, 03 Feb 2023 12:18:38 -0500, Richard Damon wrote:
>>>
>>>> On 2/3/23 11:59 AM, Mr Flibble wrote:
>>>>> Hi!
>>>>>
>>>>> I have an idea for a signaling simulating halt decider that forks the
>>>>> simulation into two branches if the input calls the halt decider as
>>>>> per [Strachey 1965]'s "Impossible Program":
>>>>>
>>>>> void P(void (*x)())
>>>>> {
>>>>> if (H(x, x))
>>>>> infinite_loop: goto infinite_loop;
>>>>> return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>> std::cout << "Input halts: " << H(P, P) << std::endl;
>>>>> }
>>>>>
>>>>> When the simulator detects the call to H in P it forks the simulation
>>>>> into a non-halting branch (returning 0 to P) and a halting branch
>>>>> (returning 1 to P) and continues the simulation of these two branches
>>>>> in parallel.
>>>>>
>>>>> If the non-halting branch is determined to halt AND the halting
>>>>> branch is determined to not halt then pathology is detected and
>>>>> reported via a sNaP (signaling Not a Program) signal (analogous to
>>>>> IEEE 754's sNaN (signaling Not a Number) signal)
>>>>>
>>>>> If EITHER branch is determined to be correctly decided then that will
>>>>> be the decision of the halting decider.
>>>>>
>>>>> Crucially this scheme will handle (and correctly decide) the
>>>>> following case whereby the result of H is discarded by the input:
>>>>>
>>>>> void Px(void (*x)())
>>>>> {
>>>>> (void) H(x, x);
>>>>> return;
>>>>> }
>>>>>
>>>>> Obviously my idea necessitates extending the definition of a halt
>>>>> decider:
>>>>>
>>>>> 1) Decider decision is HALTS if input halts.
>>>>> 2) Decider decision is NON-HALTING if input does not halt.
>>>>> 3) Decider rejects pathological input as invalid by signaling sNaP.
>>>>>
>>>>> Thoughts? I am probably missing something obvious as my idea appears
>>>>> to refute [Strachey 1965] and associated HP proofs which great minds
>>>>> have mulled over for decades.
>>>>>
>>>>> This refutation of the existing Halting Problem proofs has been
>>>>> confirmed by ChatGPT AI which recognises that (3) above is a category
>>>>> error:-
>>>>>
>>>>> https://twitter.com/i42Software/status/1609626194273525760
>>>>>
>>>>> The discovery of this category error is a unique achievement made by
>>>>> Mr Flibble alone and should set a new direction for Halting Problem
>>>>> related theory and research for many decades to come especially with
>>>>> quantum computers and such making a simulation-based approach
>>>>> achievable within the lifetime of the observable universe.
>>>>>
>>>>> /Flibble
>>>>
>>>> Ultimately, the problem is that your answer "3" is poorly defined.
>>>>
>>>> The issue is what should the Halt Decider give for an input that
>>>> itself signals sNaP?
>>>>
>>>> What happens if a program "traps" the sNaP adn does something with it?
>>>>
>>>> A fundamental part of the problem is that the Halt Decider needs to be
>>>> nothing more than a "normal" program in the system, without special
>>>> "powers", otherwise its domain of inputs isn't "Complete", so this
>>>> makes your definition not fit the classic definiton of a computation
>>>> theory "program".
>>>>
>>>> A Part of this issue, it that the program to decide on really needs to
>>>> be in an isolated sandbox to the decider, so the presence of the
>>>> decider doesn't limit what programs it can be given. You H, BY
>>>> DEFINITON, can't be given a totally "arbitrary" input program, as you
>>>> are defining the contents of some of the address space.
>>>>
>>>> Once you do this, the "self-reference" your system is based on goes
>>>> away. and you end up with the problem that H needs to be able to
>>>> recognize that the input contains a machine that is the "equivalent"
>>>> of itself, which might not be an identical representation. In fact,
>>>> one key issue is that it can be shown that a given "program" can have
>>>> an infinite number of identically acting variations in representation,
>>>> so the problem of detecting a copy of somthing equivalent to yourself
>>>> is not computable.
>>>
>>> The category error that I alone have identified prevents the scheme you
>>> describe from being possible: the self reference cannot be broken with
>>> a sandbox given the definition of the Halting Problem.
>>>
>>> /Flibble
>>
>> What is the "Category Error"
>>
>> P is a program that takes an input, and generates a result.
>>
>> If H is a Halt Decider, it is supposed to be able to take in ANY
>> program, and answer what it will do, thus to be correct it needs to be
>> able to correctly answer about this P, even if it has been built on a
>> copy of this H, so it is able to answer contradictory.
>>
>> The only "Category Error" is thinking that H can be given an "arbitrary
>> program" as required.
>>
>> Removing the "Sandbox", all you are doing is beginning with an admission
>> that you can't actually handle "Any Program".
>>
>> In fact, this form of a system doesn't even really have a "tape" for a
>> Turing Machine, and there is no (at least simple) way to modify it to
>> have one, as without the idea of independent address spaces for Decider,
>> Input machine, and input we can't actually fully express the problem.
>>
>> The issue is that P needs to be given a "copy" of itself that it can
>> "duplicate", and H is allowed (and in fact almost certainly would want
>> to) write to, but there is no way to have two independent copies of the
>> code of P as, without a "sandbox", since P is at a specific address,
>> that copy must be at that address in memory, and thus the two copies
>> overlap and aren't independent.
>
> A category error occurs when we attempt to predicate upon a non-existent
> relationship between two orthogonal categories: in this case the two
> caregories are the halting decider and the program/input pair being
> decided upon. This category error manifests due to the self referencing
> pathology of the current Halting Problem definition (and proofs predicated
> upon that definition).
>
> /Flibble

So what is the error? Ar you saying it is a caterory error when ever a
problem is found not to have a solution?

It isn't a category error because the category for a decider to try to
answer on is ALL INPUT, and for a halt decider, that is ALL PROGRAMS.
The fact that, BY DESIGN, the category of all programs includes programs
built on copies of another, there is no "Category Error" in the design of P.

All that is shown is that the specifications of the defined Halting
Problem are IMPOSSIBLE to be meet by a program. That isn't a "Category
Error", that is a Result.

Unless you think there is something fundamentally wrong with some
problems being impossible to solve, there is no problem here. If you DO
think there is something fundamentally wrong with some problems not
having solutions, then YOU have the problem, because it is a fact of
nature that MANY problems don't have a solution, and if you don't allow
the posing of problems that might not have a solution, you can't allow
ANY problem to be posed until you first prove it has one.