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/12/23 9:24 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.

There is no "Pathological Input".

If H answers Halting or non-Halting then the P built by the template
always does a valid action, which is different then what H said, so H is
incorrect.

All you have done is added a "SNaP" answer which is a "I don't know",
but if a program ending with a SNaP responce is considered halting, then
the decider is just WRONG as Halting WOULD be the correct answer.

IF you want to try to "extend" the concept of a Halting Decider this
way, you need to define a LOT of details.

Some things, What is the correct answer for an input that ends with a
SNaP result?

Since by classical computation theory, this SNaP answer by H is
trappable by the P that calls it, and can be converted into either
Halting or Non-Halting behavior. Then does a halting problem have
possible TWO correct answers, one being the resultant
Halting/Non-Halting behavior that results, and then possible a SNaP
answer (which is dependent on what decider you ask).

This breaks the classical property that the answer to a question about a
machine/input combination is just a function of that machine/input
combination, and NOT a function of who you ask. This is basically saying
that questions don't just HAVE correct answers, but that truth is
relative to who you ask.

If you try to make the SNaP trap uncatchable, it breaks most of the
usefulness of compuations, so you are going to need to show that somehow
this field has a real use.

>
> 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

So? The "Circurlar Reference" that ChatGPT found just shows that the
Decider is broken and doesn't give an answer in finite time.

Note, ChatGPT says that it is unable to decide if the input Halts, which
is exactly the results predicted by the Halting Problem Theorem, that
there exists some inputs which can not be decided by a Halt Decider.

You STILL Haven't explained you "Categpory Error".

Are you saying that somehow P isn't actually a Program? (since that is
the category of inputs that H is supposed to take in).

P is built with simple constructions primatives from H, so the only way
that P isn't a Program is if H isn't a Program, but if H isn't a
Program, it can't be a "Decider", since a Decider is simply a subset of
the category of Programs with extra requirements on them.

Somehow you seem to think that makes it not a valid input.

That is exactly like saying you can't enter a Poodle into a Dog Show as
Poodles are a different distinct category of things then Dogs, ignoring
that the distinction is that it is a proper subset of Dog, and thus, all
Poodles ARE Dogs, so anything that needs a Dog can take a Poodle.

On Sun, 12 Feb 2023 15:28:11 -0500, Richard Damon wrote:

> On 2/12/23 9:24 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.
>
> There is no "Pathological Input".
Of course there is and you know exactly what that pathological input
consists of. This of course means that YOU are a pathological liar -- I
do not debate with such people. I see you are a Christian, this explains
a lot, Christians just love to tell lies.

[snip]

/Flibble

On 2/12/23 3:49 PM, Mr Flibble wrote:
> On Sun, 12 Feb 2023 15:28:11 -0500, Richard Damon wrote:
>
>> On 2/12/23 9:24 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.
>>
>> There is no "Pathological Input".
>
> Of course there is and you know exactly what that pathological input
> consists of. This of course means that YOU are a pathological liar -- I
> do not debate with such people. I see you are a Christian, this explains
> a lot, Christians just love to tell lies.
>
> [snip]
>
> /Flibble

There is no "Pathological Input" in the sense that it breaks the rules
for what the input is allowed to be.

YOU claiming that input is in some way "illegal" means that you need to
show what rule it breaks.

Your failure to do that means that YOU are the Pathological liar.

Your trying to brand "Christians" as "Liars' is just a logical fallacy.

You make it becaue you don't actually have any grounds to defend your
statement.

I could say that is because non-believers have no reason to try to tell
the truth.

Until you answer these refuations, you are just admitting you have no
basis for you claims.

Unless you can show what is actually INVALID about the input, you are
just admitting you are a liar to say it is.

The fact that it generates a condition that means that H can not give a
correct answer, just shows that we can make a valid program that H can
not give a correct answer to, nothing wrong with that, it just proves
the point.

On Sun, 12 Feb 2023 16:17:38 -0500, Richard Damon wrote:

> On 2/12/23 3:49 PM, Mr Flibble wrote:
>> On Sun, 12 Feb 2023 15:28:11 -0500, Richard Damon wrote:
>>
>>> On 2/12/23 9:24 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.
>>>
>>> There is no "Pathological Input".
>>
>> Of course there is and you know exactly what that pathological input
>> consists of. This of course means that YOU are a pathological liar --
>> I do not debate with such people. I see you are a Christian, this
>> explains a lot, Christians just love to tell lies.
>>
>> [snip]
>>
>> /Flibble
>
>
> There is no "Pathological Input" in the sense that it breaks the rules
> for what the input is allowed to be.
>
> YOU claiming that input is in some way "illegal" means that you need to
> show what rule it breaks.

I have described the category error present in the problem definition many
times.

>
> Your failure to do that means that YOU are the Pathological liar.

Nope, see above.

>
> Your trying to brand "Christians" as "Liars' is just a logical fallacy.
>
> You make it becaue you don't actually have any grounds to defend your
> statement.
>
> I could say that is because non-believers have no reason to try to tell
> the truth.

Christianity, like any religion, is irrational. You are irrational and
not to be trusted in matters of logic, science or mathematics.

/Flibble

On 2/12/23 5:34 PM, Mr Flibble wrote:
> On Sun, 12 Feb 2023 16:17:38 -0500, Richard Damon wrote:
>
>> On 2/12/23 3:49 PM, Mr Flibble wrote:
>>> On Sun, 12 Feb 2023 15:28:11 -0500, Richard Damon wrote:
>>>
>>>> On 2/12/23 9:24 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.
>>>>
>>>> There is no "Pathological Input".
>>>
>>> Of course there is and you know exactly what that pathological input
>>> consists of. This of course means that YOU are a pathological liar --
>>> I do not debate with such people. I see you are a Christian, this
>>> explains a lot, Christians just love to tell lies.
>>>
>>> [snip]
>>>
>>> /Flibble
>>
>>
>> There is no "Pathological Input" in the sense that it breaks the rules
>> for what the input is allowed to be.
>>
>> YOU claiming that input is in some way "illegal" means that you need to
>> show what rule it breaks.
>
> I have described the category error present in the problem definition many
> times.

Really? You make the false claim that deciders and programs are totally
distinct categories.

That is like saying Poodles are not Dogs.

>
>>
>> Your failure to do that means that YOU are the Pathological liar.
>
> Nope, see above.

You mean where you don't explain why the input isn't a program?

>
>>
>> Your trying to brand "Christians" as "Liars' is just a logical fallacy.
>>
>> You make it becaue you don't actually have any grounds to defend your
>> statement.
>>
>> I could say that is because non-believers have no reason to try to tell
>> the truth.
>
> Christianity, like any religion, is irrational. You are irrational and
> not to be trusted in matters of logic, science or mathematics.
>
> /Flibble

Nope, You are just proving you are illogical.

I guess you don't understand that many of the great scientist of the
past were Christians.

You are just proving you base your logic on fallacies.

The fact that you can't explaim your claim of a category error, just
proves you are making up your arguement.

What is the category that the input to a halt decider needs to be:

The description of a Program and its input.

What is H passes as its input:

The Address (a descriptio) of P (a program, and its input)

Until you explain how that makes the input a category error, you are
just shown to be a lying idiot.

On Sun, 12 Feb 2023 17:49:47 -0500, Richard Damon wrote:

> On 2/12/23 5:34 PM, Mr Flibble wrote:
>> On Sun, 12 Feb 2023 16:17:38 -0500, Richard Damon wrote:
>>
>>> On 2/12/23 3:49 PM, Mr Flibble wrote:
>>>> On Sun, 12 Feb 2023 15:28:11 -0500, Richard Damon wrote:
>>>>
>>>>> On 2/12/23 9:24 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.
>>>>>
>>>>> There is no "Pathological Input".
>>>>
>>>> Of course there is and you know exactly what that pathological input
>>>> consists of. This of course means that YOU are a pathological liar
>>>> --
>>>> I do not debate with such people. I see you are a Christian, this
>>>> explains a lot, Christians just love to tell lies.
>>>>
>>>> [snip]
>>>>
>>>> /Flibble
>>>
>>>
>>> There is no "Pathological Input" in the sense that it breaks the rules
>>> for what the input is allowed to be.
>>>
>>> YOU claiming that input is in some way "illegal" means that you need
>>> to show what rule it breaks.
>>
>> I have described the category error present in the problem definition
>> many times.
>
> Really? You make the false claim that deciders and programs are totally
> distinct categories.
>
> That is like saying Poodles are not Dogs.

No, I said the decider and the decidee are distinct categories; they are
distinct categories even if they are both programs; unfortunately you have
to have an iota of intelligence to understand why this is the case,
intelligence you appear to be lacking.

>
>
>>
>>> Your failure to do that means that YOU are the Pathological liar.
>>
>> Nope, see above.
>
> You mean where you don't explain why the input isn't a program?

I never claimed that the input wasn't a program.

>
>
>>
>>> Your trying to brand "Christians" as "Liars' is just a logical
>>> fallacy.
>>>
>>> You make it becaue you don't actually have any grounds to defend your
>>> statement.
>>>
>>> I could say that is because non-believers have no reason to try to
>>> tell the truth.
>>
>> Christianity, like any religion, is irrational. You are irrational and
>> not to be trusted in matters of logic, science or mathematics.
>>
>> /Flibble
>
> Nope, You are just proving you are illogical.

Believing in a magical sky daddy is irrational: you are irrational, and by
extension illogical.

[snip]

/Flibble

On 2/12/23 6:13 PM, Mr Flibble wrote:
> On Sun, 12 Feb 2023 17:49:47 -0500, Richard Damon wrote:
>
>> On 2/12/23 5:34 PM, Mr Flibble wrote:
>>> On Sun, 12 Feb 2023 16:17:38 -0500, Richard Damon wrote:
>>>
>>>> On 2/12/23 3:49 PM, Mr Flibble wrote:
>>>>> On Sun, 12 Feb 2023 15:28:11 -0500, Richard Damon wrote:
>>>>>
>>>>>> On 2/12/23 9:24 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.
>>>>>>
>>>>>> There is no "Pathological Input".
>>>>>
>>>>> Of course there is and you know exactly what that pathological input
>>>>> consists of. This of course means that YOU are a pathological liar
>>>>> --
>>>>> I do not debate with such people. I see you are a Christian, this
>>>>> explains a lot, Christians just love to tell lies.
>>>>>
>>>>> [snip]
>>>>>
>>>>> /Flibble
>>>>
>>>>
>>>> There is no "Pathological Input" in the sense that it breaks the rules
>>>> for what the input is allowed to be.
>>>>
>>>> YOU claiming that input is in some way "illegal" means that you need
>>>> to show what rule it breaks.
>>>
>>> I have described the category error present in the problem definition
>>> many times.
>>
>> Really? You make the false claim that deciders and programs are totally
>> distinct categories.
>>
>> That is like saying Poodles are not Dogs.
>
> No, I said the decider and the decidee are distinct categories; they are
> distinct categories even if they are both programs; unfortunately you have
> to have an iota of intelligence to understand why this is the case,
> intelligence you appear to be lacking.
>
>>
>>
>>>
>>>> Your failure to do that means that YOU are the Pathological liar.
>>>
>>> Nope, see above.
>>
>> You mean where you don't explain why the input isn't a program?
>
> I never claimed that the input wasn't a program.
>
>>
>>
>>>
>>>> Your trying to brand "Christians" as "Liars' is just a logical
>>>> fallacy.
>>>>
>>>> You make it becaue you don't actually have any grounds to defend your
>>>> statement.
>>>>
>>>> I could say that is because non-believers have no reason to try to
>>>> tell the truth.
>>>
>>> Christianity, like any religion, is irrational. You are irrational and
>>> not to be trusted in matters of logic, science or mathematics.
>>>
>>> /Flibble
>>
>> Nope, You are just proving you are illogical.
>
> Believing in a magical sky daddy is irrational: you are irrational, and by
> extension illogical.
>
> [snip]
>
> /Flibble

So it is more rational to think it just came into existance with a poof
out of nothing? (In violation of all the laws of Physics)

Or do you not beleive in Entropy?

On Sun, 12 Feb 2023 19:20:56 -0500, Richard Damon wrote:

> On 2/12/23 6:13 PM, Mr Flibble wrote:
>> On Sun, 12 Feb 2023 17:49:47 -0500, Richard Damon wrote:
>>
>>> On 2/12/23 5:34 PM, Mr Flibble wrote:
>>>> On Sun, 12 Feb 2023 16:17:38 -0500, Richard Damon wrote:
>>>>
>>>>> On 2/12/23 3:49 PM, Mr Flibble wrote:
>>>>>> On Sun, 12 Feb 2023 15:28:11 -0500, Richard Damon wrote:
>>>>>>
>>>>>>> On 2/12/23 9:24 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.
>>>>>>>
>>>>>>> There is no "Pathological Input".
>>>>>>
>>>>>> Of course there is and you know exactly what that pathological
>>>>>> input consists of. This of course means that YOU are a
>>>>>> pathological liar --
>>>>>> I do not debate with such people. I see you are a Christian, this
>>>>>> explains a lot, Christians just love to tell lies.
>>>>>>
>>>>>> [snip]
>>>>>>
>>>>>> /Flibble
>>>>>
>>>>>
>>>>> There is no "Pathological Input" in the sense that it breaks the
>>>>> rules for what the input is allowed to be.
>>>>>
>>>>> YOU claiming that input is in some way "illegal" means that you
>>>>> need to show what rule it breaks.
>>>>
>>>> I have described the category error present in the problem definition
>>>> many times.
>>>
>>> Really? You make the false claim that deciders and programs are
>>> totally distinct categories.
>>>
>>> That is like saying Poodles are not Dogs.
>>
>> No, I said the decider and the decidee are distinct categories; they
>> are distinct categories even if they are both programs; unfortunately
>> you have to have an iota of intelligence to understand why this is the
>> case, intelligence you appear to be lacking.
>>
>>
>>>
>>>
>>>>> Your failure to do that means that YOU are the Pathological liar.
>>>>
>>>> Nope, see above.
>>>
>>> You mean where you don't explain why the input isn't a program?
>>
>> I never claimed that the input wasn't a program.
>>
>>
>>>
>>>
>>>>> Your trying to brand "Christians" as "Liars' is just a logical
>>>>> fallacy.
>>>>>
>>>>> You make it becaue you don't actually have any grounds to defend
>>>>> your statement.
>>>>>
>>>>> I could say that is because non-believers have no reason to try to
>>>>> tell the truth.
>>>>
>>>> Christianity, like any religion, is irrational. You are irrational
>>>> and not to be trusted in matters of logic, science or mathematics.
>>>>
>>>> /Flibble
>>>
>>> Nope, You are just proving you are illogical.
>>
>> Believing in a magical sky daddy is irrational: you are irrational, and
>> by extension illogical.
>>
>> [snip]
>>
>> /Flibble
>
> So it is more rational to think it just came into existance with a poof
> out of nothing? (In violation of all the laws of Physics)
>
> Or do you not beleive in Entropy?

You are assuming that the universe has a beginning .. it could always have
been here so no need for a cause (creation); a big bang doesn't have to
mean a beginning, there could be an infinite number of big bangs happening
all the time.

/Flibble

On 2/13/23 2:10 PM, Mr Flibble wrote:
> On Sun, 12 Feb 2023 19:20:56 -0500, Richard Damon wrote:
>
>> On 2/12/23 6:13 PM, Mr Flibble wrote:
>>> On Sun, 12 Feb 2023 17:49:47 -0500, Richard Damon wrote:
>>>
>>>> On 2/12/23 5:34 PM, Mr Flibble wrote:
>>>>> On Sun, 12 Feb 2023 16:17:38 -0500, Richard Damon wrote:
>>>>>
>>>>>> On 2/12/23 3:49 PM, Mr Flibble wrote:
>>>>>>> On Sun, 12 Feb 2023 15:28:11 -0500, Richard Damon wrote:
>>>>>>>
>>>>>>>> On 2/12/23 9:24 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.
>>>>>>>>
>>>>>>>> There is no "Pathological Input".
>>>>>>>
>>>>>>> Of course there is and you know exactly what that pathological
>>>>>>> input consists of. This of course means that YOU are a
>>>>>>> pathological liar --
>>>>>>> I do not debate with such people. I see you are a Christian, this
>>>>>>> explains a lot, Christians just love to tell lies.
>>>>>>>
>>>>>>> [snip]
>>>>>>>
>>>>>>> /Flibble
>>>>>>
>>>>>>
>>>>>> There is no "Pathological Input" in the sense that it breaks the
>>>>>> rules for what the input is allowed to be.
>>>>>>
>>>>>> YOU claiming that input is in some way "illegal" means that you
>>>>>> need to show what rule it breaks.
>>>>>
>>>>> I have described the category error present in the problem definition
>>>>> many times.
>>>>
>>>> Really? You make the false claim that deciders and programs are
>>>> totally distinct categories.
>>>>
>>>> That is like saying Poodles are not Dogs.
>>>
>>> No, I said the decider and the decidee are distinct categories; they
>>> are distinct categories even if they are both programs; unfortunately
>>> you have to have an iota of intelligence to understand why this is the
>>> case, intelligence you appear to be lacking.
>>>
>>>
>>>>
>>>>
>>>>>> Your failure to do that means that YOU are the Pathological liar.
>>>>>
>>>>> Nope, see above.
>>>>
>>>> You mean where you don't explain why the input isn't a program?
>>>
>>> I never claimed that the input wasn't a program.
>>>
>>>
>>>>
>>>>
>>>>>> Your trying to brand "Christians" as "Liars' is just a logical
>>>>>> fallacy.
>>>>>>
>>>>>> You make it becaue you don't actually have any grounds to defend
>>>>>> your statement.
>>>>>>
>>>>>> I could say that is because non-believers have no reason to try to
>>>>>> tell the truth.
>>>>>
>>>>> Christianity, like any religion, is irrational. You are irrational
>>>>> and not to be trusted in matters of logic, science or mathematics.
>>>>>
>>>>> /Flibble
>>>>
>>>> Nope, You are just proving you are illogical.
>>>
>>> Believing in a magical sky daddy is irrational: you are irrational, and
>>> by extension illogical.
>>>
>>> [snip]
>>>
>>> /Flibble
>>
>> So it is more rational to think it just came into existance with a poof
>> out of nothing? (In violation of all the laws of Physics)
>>
>> Or do you not beleive in Entropy?
>
> You are assuming that the universe has a beginning .. it could always have
> been here so no need for a cause (creation); a big bang doesn't have to
> mean a beginning, there could be an infinite number of big bangs happening
> all the time.
>
> /Flibble

So, you don't believe in Entropy?