Hi!

I have an idea for a 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.

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

Thoughts? I am probably missing something obvious.

/Flibble

On Monday, 4 July 2022 at 01:31:46 UTC+8, Mr Flibble wrote:
> Hi!
>
> I have an idea for a 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.
>
> 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;
> }
>
> Thoughts? I am probably missing something obvious.
>
> /Flibble

You should declare copyright first, then public the source before olcott does.
Although I don't think olcott has technical competent enough data to sue you,
less trouble is always better.

On Sun, 3 Jul 2022 10:57:40 -0700 (PDT)
wij <wyniijj2@gmail.com> wrote:

> On Monday, 4 July 2022 at 01:31:46 UTC+8, Mr Flibble wrote:
> > Hi!
> >
> > I have an idea for a 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.
> >
> > 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;
> > }
> >
> > Thoughts? I am probably missing something obvious.
> >
> > /Flibble
>
> You should declare copyright first, then public the source before
> olcott does. Although I don't think olcott has technical competent
> enough data to sue you, less trouble is always better.

No need, the timestamps of the Usenet posts should be sufficient to
prove prior art. :)

/Flibble

On 7/3/22 1:57 PM, wij wrote:
> On Monday, 4 July 2022 at 01:31:46 UTC+8, Mr Flibble wrote:
>> Hi!
>>
>> I have an idea for a 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.
>>
>> 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;
>> }
>>
>> Thoughts? I am probably missing something obvious.
>>
>> /Flibble
>
> You should declare copyright first, then public the source before olcott does.
> Although I don't think olcott has technical competent enough data to sue you,
> less trouble is always better.

Actually, based on the Berne Convention, Copyright exist at the moment
of artistic creation even without an explicit declaration of claim.
Explicit mention of Copyright just makes explicit the ownership (but the
form of an e-mail tends to make that clear, but Mr Flibble would need to
break his pseudonymity to actually assert their Copyright.

The declaration and registration might be needed to file for damages for
infringement.

Peter Olcott's having a Copyright notice in his footer likely ands NO
extra protection to his posts, and in fact it might be argued that it
dilutes his claims on his other more deliberate writings.

Also, the fact that his notice doesn't acknowledge his use of other's
copywritten materials while trying to apparently strengthen his own
assertion might open defenses for others to use his material.

On Sun, 3 Jul 2022 17:35:09 -0400
Richard Damon <Richard@Damon-Family.org> wrote:

> On 7/3/22 1:57 PM, wij wrote:
> > On Monday, 4 July 2022 at 01:31:46 UTC+8, Mr Flibble wrote:
> >> Hi!
> >>
> >> I have an idea for a 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.
> >>
> >> 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;
> >> }
> >>
> >> Thoughts? I am probably missing something obvious.
> >>
> >> /Flibble
> >
> > You should declare copyright first, then public the source before
> > olcott does. Although I don't think olcott has technical competent
> > enough data to sue you, less trouble is always better.
>
> Actually, based on the Berne Convention, Copyright exist at the
> moment of artistic creation even without an explicit declaration of
> claim. Explicit mention of Copyright just makes explicit the
> ownership (but the form of an e-mail tends to make that clear, but Mr
> Flibble would need to break his pseudonymity to actually assert their
> Copyright.

My real identity is: Leigh V. Johnston, BSc (Hons).

I hereby assert my copyright for the forking simulating halt decider. :)

/Flibble

On 03/07/2022 18:31, Mr Flibble wrote:
> Hi!
>
> I have an idea for a 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.

Halt deciders do not report "pathology", they accept or reject their input. In this situation, your
halt decider still has to either accept or reject the input, even when it has reached this scenario.

If you want to talk about TMs having 3 reporting options "accept", "reject", "pathology", then it is
not a halting decider, and does not refute anything in the Linz (and similar) HP proof. There are
plenty of TMs that either "give up/pathology/don't know", or CORRECTLY accept/reject their input as
halting/non-halting! No kudos points for coming up with a complex implementation for one of these,
I'm afraid.

>
> 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;
> }
>
> Thoughts? I am probably missing something obvious.
>
> /Flibble
>

The real "crucial question" is whether the scheme can be used to defeat the argument used in
Linz/similar HP proofs - it cannot.

Mike.

On Sun, 3 Jul 2022 22:50:30 +0100
Mike Terry <news.dead.person.stones@darjeeling.plus.com> wrote:

> On 03/07/2022 18:31, Mr Flibble wrote:
> > Hi!
> >
> > I have an idea for a 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.
>
> Halt deciders do not report "pathology", they accept or reject their
> input. In this situation, your halt decider still has to either
> accept or reject the input, even when it has reached this scenario.
>
> If you want to talk about TMs having 3 reporting options "accept",
> "reject", "pathology", then it is not a halting decider, and does not
> refute anything in the Linz (and similar) HP proof. There are plenty
> of TMs that either "give up/pathology/don't know", or CORRECTLY
> accept/reject their input as halting/non-halting! No kudos points
> for coming up with a complex implementation for one of these, I'm
> afraid.

I would say my solution is simple not complex and as such I would be
surprised if I am the first to come up with this particular solution.

Yes, I agree I am redefining how a halting decider can answer:

1) Input halts
2) Input does not halt
3) Exception (input is invalid, i.e. pathological)

I call such a halting decider a "signaling halting decider" which
raises an invalid operation exception if pathological input is detected
similar to the signaling NaN (sNaN) of IEEE 754.

/Flibble

On 7/3/22 6:07 PM, Mr Flibble wrote:
> On Sun, 3 Jul 2022 22:50:30 +0100
> Mike Terry <news.dead.person.stones@darjeeling.plus.com> wrote:
>
>> On 03/07/2022 18:31, Mr Flibble wrote:
>>> Hi!
>>>
>>> I have an idea for a 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.
>>
>> Halt deciders do not report "pathology", they accept or reject their
>> input. In this situation, your halt decider still has to either
>> accept or reject the input, even when it has reached this scenario.
>>
>> If you want to talk about TMs having 3 reporting options "accept",
>> "reject", "pathology", then it is not a halting decider, and does not
>> refute anything in the Linz (and similar) HP proof. There are plenty
>> of TMs that either "give up/pathology/don't know", or CORRECTLY
>> accept/reject their input as halting/non-halting! No kudos points
>> for coming up with a complex implementation for one of these, I'm
>> afraid.
>
> I would say my solution is simple not complex and as such I would be
> surprised if I am the first to come up with this particular solution.
>
> Yes, I agree I am redefining how a halting decider can answer:
>
> 1) Input halts
> 2) Input does not halt
> 3) Exception (input is invalid, i.e. pathological)
>
> I call such a halting decider a "signaling halting decider" which
> raises an invalid operation exception if pathological input is detected
> similar to the signaling NaN (sNaN) of IEEE 754.
>
> /Flibble
>

The one problem is that the "Pathological" input is NOT "Invalid", in
the sense of not a valid input to be decided. You might try to define
detecting that the input is contradictory, but that actually gets hard
to define what that means, since if we are in the domain of REAL
seperate computations for decider and decided program, detecting that
the program is using a sufficiently close copy of yourself is, I
beleive, another impossible task. You also have an issue with figuing
out what is the "contrary" behavior to "contrary".

You can just give results of Halts, Non-Halting, and "I don't know and I
give up", the last never being wrong but not actually providing any
information, and perhaps you can grade such a decider by how small that
last class is.

On 03/07/2022 23:07, Mr Flibble wrote:
> I would say my solution is simple not complex and as such I would be
> surprised if I am the first to come up with this particular solution.

No need for surprise. Every man and his dog comes up with something
similar whenever a reasonably ept audience is introduced to the HP.

> Yes, I agree I am redefining how a halting decider can answer:
> 1) Input halts
> 2) Input does not halt
> 3) Exception (input is invalid, i.e. pathological)

Well, now it depends what you mean by "pathological". If you merely
mean input that syntactically conforms to some recognisable pattern, then
this is easy to do and helps not in the slightest; it's just another way
to divide cases into "halts", "doesn't halt", "give up". Such a division
can even be useful, but it has nothing interesting to do with the HP. If
OTOH you mean something semantic detectable [only] when the simulation
runs, then you run up against the problem that all interesting semantic
outcomes are just as undetectable/undecidable as in the original HP. IOW,
you will have done nothing useful to the theory of the HP, and therefore
nothing publishable.

You are as free as PO to waste your remaining time on this planet
in a fruitless quest to buck the HP. But I advise against it. The HP is
settled; there are lots of other problems where you could perhaps make
real progress, such as Goldbach or Collatz or twin primes or ....

I think the problem is that the cranks think that failure to solve
instances of the HP is simply a matter of needing more clever programming,
or alternatively that there are just a handful of difficult cases that you
need to weed out. Not so!

--
Andy Walker, Nottingham.
Andy's music pages: www.cuboid.me.uk/andy/Music
Composer of the day: www.cuboid.me.uk/andy/Music/Composers/Necke

On Mon, 4 Jul 2022 00:21:12 +0100
Andy Walker <anw@cuboid.co.uk> wrote:

> On 03/07/2022 23:07, Mr Flibble wrote:
> > I would say my solution is simple not complex and as such I would be
> > surprised if I am the first to come up with this particular
> > solution.
>
> No need for surprise. Every man and his dog comes up with
> something similar whenever a reasonably ept audience is introduced to
> the HP.
>
> > Yes, I agree I am redefining how a halting decider can answer:
> > 1) Input halts
> > 2) Input does not halt
> > 3) Exception (input is invalid, i.e. pathological)
>
> Well, now it depends what you mean by "pathological". If you
> merely mean input that syntactically conforms to some recognisable
> pattern, then this is easy to do and helps not in the slightest;
> it's just another way to divide cases into "halts", "doesn't halt",
> "give up". Such a division can even be useful, but it has nothing
> interesting to do with the HP. If OTOH you mean something semantic
> detectable [only] when the simulation runs, then you run up against
> the problem that all interesting semantic outcomes are just as
> undetectable/undecidable as in the original HP. IOW, you will have
> done nothing useful to the theory of the HP, and therefore nothing
> publishable.
>
> You are as free as PO to waste your remaining time on this
> planet in a fruitless quest to buck the HP. But I advise against it.
> The HP is settled; there are lots of other problems where you could
> perhaps make real progress, such as Goldbach or Collatz or twin
> primes or ....
>
> I think the problem is that the cranks think that failure to
> solve instances of the HP is simply a matter of needing more clever
> programming, or alternatively that there are just a handful of
> difficult cases that you need to weed out. Not so!
"The HP is settled" reminds me of religious cranks who assert "God does
exist" or atheist cranks who assert "God does not exist".

You can only claim that the HP is "settled" if there is a MATHEMATICAL
proof of same.

/Flibble

Mr Flibble <flibble@reddwarf.jmc> writes:

> On Mon, 4 Jul 2022 00:21:12 +0100
> Andy Walker <anw@cuboid.co.uk> wrote:

>> You are as free as PO to waste your remaining time on this
>> planet in a fruitless quest to buck the HP. But I advise against it.
>> The HP is settled; there are lots of other problems where you could
>> perhaps make real progress, such as Goldbach or Collatz or twin
>> primes or ....
>>
>> I think the problem is that the cranks think that failure to
>> solve instances of the HP is simply a matter of needing more clever
>> programming, or alternatively that there are just a handful of
>> difficult cases that you need to weed out. Not so!
>
> "The HP is settled" reminds me of religious cranks who assert "God does
> exist" or atheist cranks who assert "God does not exist".
>
> You can only claim that the HP is "settled" if there is a MATHEMATICAL
> proof of same.

Have you not been following? That's exactly what there is (several, in
fact) provided you frame the problem in formal terms.

--
Ben.

Mr Flibble <flibble@reddwarf.jmc> writes:

> I hereby assert my copyright for the forking simulating halt
> decider. :)

I note the smiley, but you can't copyright an idea. Copyright pertains
to forms of expression, even when the idea is not the author's. I will have
copyright on any sufficiently novel exposition I might publish about
your ideas!

--
Ben.

On Mon, 04 Jul 2022 02:27:58 +0100
Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:

> Mr Flibble <flibble@reddwarf.jmc> writes:
>
> > I hereby assert my copyright for the forking simulating halt
> > decider. :)
>
> I note the smiley, but you can't copyright an idea. Copyright
> pertains to forms of expression, even when the idea is not the
> author's. I will have copyright on any sufficiently novel exposition
> I might publish about your ideas!
I published my idea in this forum and that exposition is what I am
copyrighting.

/Flibble

On Monday, 4 July 2022 at 00:21:15 UTC+1, Andy Walker wrote:
>
> You are as free as PO to waste your remaining time on this planet
> in a fruitless quest to buck the HP. But I advise against it. The HP is
> settled; there are lots of other problems where you could perhaps make
> real progress, such as Goldbach or Collatz or twin primes or ....
>
There's the crank who tries to solve the angle trisection problem or
similar. Then there's the slightly more informed crank who tries the
same thing with twin primes. The slightly more informed crank is not
trying something that is inherently impossible. But he's trying to use the
techniques taught in high school algebra to solve a long outstanding
problem which has resisted all such attempts. He stands no chance of
success, and is still a crank.

It's difficult to make progress in any discipline. Mathematics isn't an
exception, but it is usual in that you don't need any equipment or resources
that the average man doesn't have. You need to find a small, doable problem
which almost certainly won't set the world alight, but isn't fully understood.
To identify such problems you need a good background (so I can't actually
suggest something to work on).

Mr Flibble <flibble@reddwarf.jmc> writes:

> On Mon, 04 Jul 2022 02:27:58 +0100
> Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>
>> Mr Flibble <flibble@reddwarf.jmc> writes:
>>
>> > I hereby assert my copyright for the forking simulating halt
>> > decider. :)
>>
>> I note the smiley, but you can't copyright an idea. Copyright
>> pertains to forms of expression, even when the idea is not the
>> author's. I will have copyright on any sufficiently novel exposition
>> I might publish about your ideas!
>
> I published my idea in this forum and that exposition is what I am
> copyrighting.

OK. I'm just pointing out that there's little point in doing that. The
exposition is probably not what you care about.

--
Ben.

On 7/4/2022 6:17 PM, Ben Bacarisse wrote:
> Mr Flibble <flibble@reddwarf.jmc> writes:
>
>> On Mon, 04 Jul 2022 02:27:58 +0100
>> Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>>
>>> Mr Flibble <flibble@reddwarf.jmc> writes:
>>>
>>>> I hereby assert my copyright for the forking simulating halt
>>>> decider. :)
>>>
>>> I note the smiley, but you can't copyright an idea. Copyright
>>> pertains to forms of expression, even when the idea is not the
>>> author's. I will have copyright on any sufficiently novel exposition
>>> I might publish about your ideas!
>>
>> I published my idea in this forum and that exposition is what I am
>> copyrighting.
>
> OK. I'm just pointing out that there's little point in doing that. The
> exposition is probably not what you care about.
>

I publish to this forum primarily to establish original authorship of my
ideas. Even though everyone here had only reviewed my work for the
purpose of finding fault and or rebuttal these reviews were crucially
required for me to achieve all of the progress that I have made.

Now that my work is entirely proven to be correct entirely on the basis
of established facts:

From a purely software engineering perspective (anchored in the
semantics of the x86 language) it is proven that H(P,P) correctly
predicts that its correct and complete x86 emulation of its input would
never reach the "ret" instruction (final state) of this input.

Competent reviewers are no longer willing to review it.

*Halting problem proofs refuted on the basis of software engineering*

https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On 7/4/22 8:01 PM, olcott wrote:
> On 7/4/2022 6:17 PM, Ben Bacarisse wrote:
>> Mr Flibble <flibble@reddwarf.jmc> writes:
>>
>>> On Mon, 04 Jul 2022 02:27:58 +0100
>>> Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>>>
>>>> Mr Flibble <flibble@reddwarf.jmc> writes:
>>>>
>>>>> I hereby assert my copyright for the forking simulating halt
>>>>> decider. :)
>>>>
>>>> I note the smiley, but you can't copyright an idea.  Copyright
>>>> pertains to forms of expression, even when the idea is not the
>>>> author's.  I will have copyright on any sufficiently novel exposition
>>>> I might publish about your ideas!
>>> I published my idea in this forum and that exposition is what I am
>>> copyrighting.
>>
>> OK.  I'm just pointing out that there's little point in doing that.  The
>> exposition is probably not what you care about.
>>
>
> I publish to this forum primarily to establish original authorship of my
> ideas. Even though everyone here had only reviewed my work for the
> purpose of finding fault and or rebuttal these reviews were crucially
> required for me to achieve all of the progress that I have made.
>
> Now that my work is entirely proven to be correct entirely on the basis
> of established facts:
>
> From a purely software engineering perspective (anchored in the
> semantics of the x86 language) it is proven that H(P,P) correctly
> predicts that its correct and complete x86 emulation of its input would
> never reach the "ret" instruction (final state) of this input.
>
> Competent reviewers are no longer willing to review it.
>
> *Halting problem proofs refuted on the basis of software engineering*
>
> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
>
>

Except it has been pointed out that it doesn't, because H doesn't
actually do a correct and complete x86 emulation, so you can't prove
anything based on the thing it didn't do.

That would be like saying since Trump won the 2020 election, he should
have appointed the latest Supreme Court replacement.

If you think you actually HAVE proven it, why not go away and submit the
paper?

The answer is that you know your "proof" isn't true, and need to find
better words to hide that fact.

On Monday, 4 July 2022 at 02:00:00 UTC+8, Mr Flibble wrote:
> On Sun, 3 Jul 2022 10:57:40 -0700 (PDT)
> wij <wyni...@gmail.com> wrote:
>
> > On Monday, 4 July 2022 at 01:31:46 UTC+8, Mr Flibble wrote:
> > > Hi!
> > >
> > > I have an idea for a 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.
> > >
> > > 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;
> > > }
> > >
> > > Thoughts? I am probably missing something obvious.
> > >
> > > /Flibble
> >
> > You should declare copyright first, then public the source before
> > olcott does. Although I don't think olcott has technical competent
> > enough data to sue you, less trouble is always better.
> No need, the timestamps of the Usenet posts should be sufficient to
> prove prior art. :)
>
> /Flibble

The idea of fork-simulation halting decider indeed looked much advanced and
promising than the oral-based halting decider (POOH). Chance might be good
refuting the HP. comp.theory user might help you enrich the original idea if you
would share more brilliant thought.
My idea of the copyright is that if no one announce it, copyright does not exist.
Probable like the car speeding if not get caught, no breaking of the law exists (IMO).

On Wednesday, 6 July 2022 at 02:49:17 UTC+8, wij wrote:
> On Monday, 4 July 2022 at 02:00:00 UTC+8, Mr Flibble wrote:
> > On Sun, 3 Jul 2022 10:57:40 -0700 (PDT)
> > wij <wyni...@gmail.com> wrote:
> >
> > > On Monday, 4 July 2022 at 01:31:46 UTC+8, Mr Flibble wrote:
> > > > Hi!
> > > >
> > > > I have an idea for a 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.
> > > >
> > > > 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;
> > > > }
> > > >
> > > > Thoughts? I am probably missing something obvious.
> > > >
> > > > /Flibble
> > >
> > > You should declare copyright first, then public the source before
> > > olcott does. Although I don't think olcott has technical competent
> > > enough data to sue you, less trouble is always better.
> > No need, the timestamps of the Usenet posts should be sufficient to
> > prove prior art. :)
> >
> > /Flibble
> The idea of fork-simulation halting decider indeed looked much advanced and
> promising than the oral-based halting decider (POOH). Chance might be good
> refuting the HP. comp.theory user might help you enrich the original idea if you
> would share more brilliant thought.
> My idea of the copyright is that if no one announce it, copyright does not exist.
> Probable like the car speeding if not get caught, no breaking of the law exists (IMO).

I should say: "if not get caught, no car speeding exists."

On 7/5/2022 1:49 PM, wij wrote:
> On Monday, 4 July 2022 at 02:00:00 UTC+8, Mr Flibble wrote:
>> On Sun, 3 Jul 2022 10:57:40 -0700 (PDT)
>> wij <wyni...@gmail.com> wrote:
>>
>>> On Monday, 4 July 2022 at 01:31:46 UTC+8, Mr Flibble wrote:
>>>> Hi!
>>>>
>>>> I have an idea for a 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.
>>>>
>>>> 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;
>>>> }
>>>>
>>>> Thoughts? I am probably missing something obvious.
>>>>
>>>> /Flibble
>>>
>>> You should declare copyright first, then public the source before
>>> olcott does. Although I don't think olcott has technical competent
>>> enough data to sue you, less trouble is always better.
>> No need, the timestamps of the Usenet posts should be sufficient to
>> prove prior art. :)
>>
>> /Flibble
>
> The idea of fork-simulation halting decider indeed looked much advanced and
> promising than the oral-based halting decider (POOH). Chance might be good
> refuting the HP. comp.theory user might help you enrich the original idea if you
> would share more brilliant thought.

So basically you do not understand that it is flat out incorrect for a
function called in infinite recursion to ever return to its caller.

> My idea of the copyright is that if no one announce it, copyright does not exist.
> Probable like the car speeding if not get caught, no breaking of the law exists (IMO).

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On Wednesday, 6 July 2022 at 03:33:51 UTC+8, olcott wrote:
> On 7/5/2022 1:49 PM, wij wrote:
> > On Monday, 4 July 2022 at 02:00:00 UTC+8, Mr Flibble wrote:
> >> On Sun, 3 Jul 2022 10:57:40 -0700 (PDT)
> >> wij <wyni...@gmail.com> wrote:
> >>
> >>> On Monday, 4 July 2022 at 01:31:46 UTC+8, Mr Flibble wrote:
> >>>> Hi!
> >>>>
> >>>> I have an idea for a 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.
> >>>>
> >>>> 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;
> >>>> }
> >>>>
> >>>> Thoughts? I am probably missing something obvious.
> >>>>
> >>>> /Flibble
> >>>
> >>> You should declare copyright first, then public the source before
> >>> olcott does. Although I don't think olcott has technical competent
> >>> enough data to sue you, less trouble is always better.
> >> No need, the timestamps of the Usenet posts should be sufficient to
> >> prove prior art. :)
> >>
> >> /Flibble
> >
> > The idea of fork-simulation halting decider indeed looked much advanced and
> > promising than the oral-based halting decider (POOH). Chance might be good
> > refuting the HP. comp.theory user might help you enrich the original idea if you
> > would share more brilliant thought.
> So basically you do not understand that it is flat out incorrect for a
> function called in infinite recursion to ever return to its caller.
> > My idea of the copyright is that if no one announce it, copyright does not exist.
> > Probable like the car speeding if not get caught, no breaking of the law exists (IMO).
> --
> Copyright 2022 Pete Olcott
>
> "Talent hits a target no one else can hit;
> Genius hits a target no one else can see."
> Arthur Schopenhauer

I think Mr Flibble's fork-simulation halting decider is brilliant, original,
and could be a better candidate to refute the HP. But it is just so far unfinished.

On 7/5/2022 2:54 PM, wij wrote:
> On Wednesday, 6 July 2022 at 03:33:51 UTC+8, olcott wrote:
>> On 7/5/2022 1:49 PM, wij wrote:
>>> On Monday, 4 July 2022 at 02:00:00 UTC+8, Mr Flibble wrote:
>>>> On Sun, 3 Jul 2022 10:57:40 -0700 (PDT)
>>>> wij <wyni...@gmail.com> wrote:
>>>>
>>>>> On Monday, 4 July 2022 at 01:31:46 UTC+8, Mr Flibble wrote:
>>>>>> Hi!
>>>>>>
>>>>>> I have an idea for a 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.
>>>>>>
>>>>>> 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;
>>>>>> }
>>>>>>
>>>>>> Thoughts? I am probably missing something obvious.
>>>>>>
>>>>>> /Flibble
>>>>>
>>>>> You should declare copyright first, then public the source before
>>>>> olcott does. Although I don't think olcott has technical competent
>>>>> enough data to sue you, less trouble is always better.
>>>> No need, the timestamps of the Usenet posts should be sufficient to
>>>> prove prior art. :)
>>>>
>>>> /Flibble
>>>
>>> The idea of fork-simulation halting decider indeed looked much advanced and
>>> promising than the oral-based halting decider (POOH). Chance might be good
>>> refuting the HP. comp.theory user might help you enrich the original idea if you
>>> would share more brilliant thought.
>> So basically you do not understand that it is flat out incorrect for a
>> function called in infinite recursion to ever return to its caller.
>>> My idea of the copyright is that if no one announce it, copyright does not exist.
>>> Probable like the car speeding if not get caught, no breaking of the law exists (IMO).
>> --
>> Copyright 2022 Pete Olcott
>>
>> "Talent hits a target no one else can hit;
>> Genius hits a target no one else can see."
>> Arthur Schopenhauer
>
> I think Mr Flibble's fork-simulation halting decider is brilliant, original,
> and could be a better candidate to refute the HP. But it is just so far unfinished.

Yet Flibble does not even understand that code following an infinitely
recursive function call is dead code that is never reached.

His forking idea merely makes infinite forks of infinitely nested
emulation. The emulations are already executed in a separate process so
they are already forked.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On Tue, 5 Jul 2022 15:16:56 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 7/5/2022 2:54 PM, wij wrote:
> > On Wednesday, 6 July 2022 at 03:33:51 UTC+8, olcott wrote:
> >> On 7/5/2022 1:49 PM, wij wrote:
> >>> On Monday, 4 July 2022 at 02:00:00 UTC+8, Mr Flibble wrote:
> >>>> On Sun, 3 Jul 2022 10:57:40 -0700 (PDT)
> >>>> wij <wyni...@gmail.com> wrote:
> >>>>
> >>>>> On Monday, 4 July 2022 at 01:31:46 UTC+8, Mr Flibble wrote:
> >>>>>> Hi!
> >>>>>>
> >>>>>> I have an idea for a 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.
> >>>>>>
> >>>>>> 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;
> >>>>>> }
> >>>>>>
> >>>>>> Thoughts? I am probably missing something obvious.
> >>>>>>
> >>>>>> /Flibble
> >>>>>
> >>>>> You should declare copyright first, then public the source
> >>>>> before olcott does. Although I don't think olcott has technical
> >>>>> competent enough data to sue you, less trouble is always
> >>>>> better.
> >>>> No need, the timestamps of the Usenet posts should be sufficient
> >>>> to prove prior art. :)
> >>>>
> >>>> /Flibble
> >>>
> >>> The idea of fork-simulation halting decider indeed looked much
> >>> advanced and promising than the oral-based halting decider
> >>> (POOH). Chance might be good refuting the HP. comp.theory user
> >>> might help you enrich the original idea if you would share more
> >>> brilliant thought.
> >> So basically you do not understand that it is flat out incorrect
> >> for a function called in infinite recursion to ever return to its
> >> caller.
> >>> My idea of the copyright is that if no one announce it, copyright
> >>> does not exist. Probable like the car speeding if not get caught,
> >>> no breaking of the law exists (IMO).
> >> --
> >> Copyright 2022 Pete Olcott
> >>
> >> "Talent hits a target no one else can hit;
> >> Genius hits a target no one else can see."
> >> Arthur Schopenhauer
> >
> > I think Mr Flibble's fork-simulation halting decider is brilliant,
> > original, and could be a better candidate to refute the HP. But it
> > is just so far unfinished.
>
> Yet Flibble does not even understand that code following an
> infinitely recursive function call is dead code that is never reached.

My fork-simulation halting decider is NOT infinitely recursive as it
returns a value to its caller on each branch. It is your erroneous
decider that has an issue with infinite recursion. [Strachey 1965] is
NOT recursive so neither is my solution.

>
> His forking idea merely makes infinite forks of infinitely nested
> emulation. The emulations are already executed in a separate process
> so they are already forked.
No it doesn't as it isn't recursive; the simulator will create two
branches each time the decider is called from the input and the decider
will return halting and non-halting for each branch -- no recursion.

/Flibble

On 7/5/2022 4:01 PM, Mr Flibble wrote:
> On Tue, 5 Jul 2022 15:16:56 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 7/5/2022 2:54 PM, wij wrote:
>>> On Wednesday, 6 July 2022 at 03:33:51 UTC+8, olcott wrote:
>>>> On 7/5/2022 1:49 PM, wij wrote:
>>>>> On Monday, 4 July 2022 at 02:00:00 UTC+8, Mr Flibble wrote:
>>>>>> On Sun, 3 Jul 2022 10:57:40 -0700 (PDT)
>>>>>> wij <wyni...@gmail.com> wrote:
>>>>>>
>>>>>>> On Monday, 4 July 2022 at 01:31:46 UTC+8, Mr Flibble wrote:
>>>>>>>> Hi!
>>>>>>>>
>>>>>>>> I have an idea for a 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.
>>>>>>>>
>>>>>>>> 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;
>>>>>>>> }
>>>>>>>>
>>>>>>>> Thoughts? I am probably missing something obvious.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>
>>>>>>> You should declare copyright first, then public the source
>>>>>>> before olcott does. Although I don't think olcott has technical
>>>>>>> competent enough data to sue you, less trouble is always
>>>>>>> better.
>>>>>> No need, the timestamps of the Usenet posts should be sufficient
>>>>>> to prove prior art. :)
>>>>>>
>>>>>> /Flibble
>>>>>
>>>>> The idea of fork-simulation halting decider indeed looked much
>>>>> advanced and promising than the oral-based halting decider
>>>>> (POOH). Chance might be good refuting the HP. comp.theory user
>>>>> might help you enrich the original idea if you would share more
>>>>> brilliant thought.
>>>> So basically you do not understand that it is flat out incorrect
>>>> for a function called in infinite recursion to ever return to its
>>>> caller.
>>>>> My idea of the copyright is that if no one announce it, copyright
>>>>> does not exist. Probable like the car speeding if not get caught,
>>>>> no breaking of the law exists (IMO).
>>>> --
>>>> Copyright 2022 Pete Olcott
>>>>
>>>> "Talent hits a target no one else can hit;
>>>> Genius hits a target no one else can see."
>>>> Arthur Schopenhauer
>>>
>>> I think Mr Flibble's fork-simulation halting decider is brilliant,
>>> original, and could be a better candidate to refute the HP. But it
>>> is just so far unfinished.
>>
>> Yet Flibble does not even understand that code following an
>> infinitely recursive function call is dead code that is never reached.
>
> My fork-simulation halting decider is NOT infinitely recursive as it
> returns a value to its caller on each branch. It is your erroneous
> decider that has an issue with infinite recursion. [Strachey 1965] is
> NOT recursive so neither is my solution.
>
>>
>> His forking idea merely makes infinite forks of infinitely nested
>> emulation. The emulations are already executed in a separate process
>> so they are already forked.
>
> No it doesn't as it isn't recursive; the simulator will create two
> branches each time the decider is called from the input and the decider
> will return halting and non-halting for each branch -- no recursion.
>
> /Flibble
>
So it contradicts itself.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On Tue, 5 Jul 2022 12:54:57 -0700 (PDT)
wij <wyniijj2@gmail.com> wrote:

> On Wednesday, 6 July 2022 at 03:33:51 UTC+8, olcott wrote:
> > On 7/5/2022 1:49 PM, wij wrote:
> > > On Monday, 4 July 2022 at 02:00:00 UTC+8, Mr Flibble wrote:
> > >> On Sun, 3 Jul 2022 10:57:40 -0700 (PDT)
> > >> wij <wyni...@gmail.com> wrote:
> > >>
> > >>> On Monday, 4 July 2022 at 01:31:46 UTC+8, Mr Flibble wrote:
> > >>>> Hi!
> > >>>>
> > >>>> I have an idea for a 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.
> > >>>>
> > >>>> 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;
> > >>>> }
> > >>>>
> > >>>> Thoughts? I am probably missing something obvious.
> > >>>>
> > >>>> /Flibble
> > >>>
> > >>> You should declare copyright first, then public the source
> > >>> before olcott does. Although I don't think olcott has technical
> > >>> competent enough data to sue you, less trouble is always
> > >>> better.
> > >> No need, the timestamps of the Usenet posts should be sufficient
> > >> to prove prior art. :)
> > >>
> > >> /Flibble
> > >
> > > The idea of fork-simulation halting decider indeed looked much
> > > advanced and promising than the oral-based halting decider
> > > (POOH). Chance might be good refuting the HP. comp.theory user
> > > might help you enrich the original idea if you would share more
> > > brilliant thought.
> > So basically you do not understand that it is flat out incorrect
> > for a function called in infinite recursion to ever return to its
> > caller.
> > > My idea of the copyright is that if no one announce it, copyright
> > > does not exist. Probable like the car speeding if not get caught,
> > > no breaking of the law exists (IMO).
> > --
> > Copyright 2022 Pete Olcott
> >
> > "Talent hits a target no one else can hit;
> > Genius hits a target no one else can see."
> > Arthur Schopenhauer
>
> I think Mr Flibble's fork-simulation halting decider is brilliant,
> original, and could be a better candidate to refute the HP. But it is
> just so far unfinished.

I have too many other projects (and a day job) to juggle to allow me to
find the time to actually create an implementation from scratch however
I might give it a go as part of my work on my universal compiler,
https://neos.dev as I will have a virtual machine with which to run the
simulation. What I won't do is waste years of my life on it like Olcott
has.

/Flibble