Hi!

(N.B. I will continue to boast about this important original solution
to the halting problem until all of you stop engaging with Olcott and
his non-solution to the halting problem.)

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.

On 9/24/2022 7:45 AM, Mr Flibble wrote:
> Hi!
>
> (N.B. I will continue to boast about this important original solution
> to the halting problem until all of you stop engaging with Olcott and
> his non-solution to the halting problem.)
If my rebuttal to the halting problem proofs was incorrect then at least
one person could correctly point out an error. So far no one has done
that. Many people did point out their own false assumptions though.

> 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

This violates my copyright and would not work because you copied my idea
incorrectly. H could detect a call to itself in P that does not have P
as its input. This P could terminate normally.

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

It violates my copyright and would not work because you copied my work
incorrectly.

--
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 9/24/22 9:29 AM, olcott wrote:
> On 9/24/2022 7:45 AM, Mr Flibble wrote:
>> Hi!
>>
>> (N.B. I will continue to boast about this important original solution
>> to the halting problem until all of you stop engaging with Olcott and
>> his non-solution to the halting problem.)
> If my rebuttal to the halting problem proofs was incorrect then at least
> one person could correctly point out an error. So far no one has done
> that. Many people did point out their own false assumptions though.

So, you are just admitting your stupidity, since MANY people have
pointed out the errors in your logic.

You are apparently too dumb to understand them.

>
>> 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
>
> This violates my copyright and would not work because you copied my idea
> incorrectly. H could detect a call to itself in P that does not have P
> as its input. This P could terminate normally.
>

Which shows you don't understand what "copyright" means.

You don't copyright "ideas", you copyright artistist expression.

>> 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.
>>
>
> It violates my copyright and would not work because you copied my work
> incorrectly.
>

Again, you don't copyright ideas, only expression.

If you want to protect an idea, you need to "patent" it (if it is
patentable).

On Sat, 24 Sep 2022 08:29:47 -0500
olcott <polcott2@gmail.com> wrote:

> On 9/24/2022 7:45 AM, Mr Flibble wrote:
> > Hi!
> >
> > (N.B. I will continue to boast about this important original
> > solution to the halting problem until all of you stop engaging with
> > Olcott and his non-solution to the halting problem.)
> If my rebuttal to the halting problem proofs was incorrect then at
> least one person could correctly point out an error. So far no one
> has done that. Many people did point out their own false assumptions
> though.
>
> > 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
>
> This violates my copyright and would not work because you copied my
> idea incorrectly. H could detect a call to itself in P that does not
> have P as its input. This P could terminate normally.

I have neither violated your copyright nor copied your idea (incorrectly
or otherwise). If H is called that does not have P as its direct input
then it will still fork the simulation is at is being called within the
simulation and it will still decide P correctly if P terminates.

/Flibble

On 9/24/2022 12:02 PM, Mr Flibble wrote:
> On Sat, 24 Sep 2022 08:29:47 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> On 9/24/2022 7:45 AM, Mr Flibble wrote:
>>> Hi!
>>>
>>> (N.B. I will continue to boast about this important original
>>> solution to the halting problem until all of you stop engaging with
>>> Olcott and his non-solution to the halting problem.)
>> If my rebuttal to the halting problem proofs was incorrect then at
>> least one person could correctly point out an error. So far no one
>> has done that. Many people did point out their own false assumptions
>> though.
>>
>>> 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
>>
>> This violates my copyright and would not work because you copied my
>> idea incorrectly. H could detect a call to itself in P that does not
>> have P as its input. This P could terminate normally.
>
> I have neither violated your copyright nor copied your idea (incorrectly
> or otherwise). If H is called that does not have P as its direct input
> then it will still fork the simulation is at is being called within the
> simulation and it will still decide P correctly if P terminates.
>
> /Flibble
>

You never stated that additional qualification before and only did so on
the basis of my critique, thus both copyright violation and plagiarism.
You simply copied my work verbatim (one name was changed).

void P(u32 x)
{ if (H(x, x))
HERE: goto HERE;
return;
}

https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5

and then applied the later enhancement to my work that takes
typedef void (*ptr)();
instead of u32.

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 9/24/22 1:18 PM, olcott wrote:
> On 9/24/2022 12:02 PM, Mr Flibble wrote:
>> On Sat, 24 Sep 2022 08:29:47 -0500
>> olcott <polcott2@gmail.com> wrote:
>>
>>> On 9/24/2022 7:45 AM, Mr Flibble wrote:
>>>> Hi!
>>>>
>>>> (N.B. I will continue to boast about this important original
>>>> solution to the halting problem until all of you stop engaging with
>>>> Olcott and his non-solution to the halting problem.)
>>> If my rebuttal to the halting problem proofs was incorrect then at
>>> least one person could correctly point out an error. So far no one
>>> has done that. Many people did point out their own false assumptions
>>> though.
>>>
>>>> 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
>>>
>>> This violates my copyright and would not work because you copied my
>>> idea incorrectly. H could detect a call to itself in P that does not
>>> have P as its input. This P could terminate normally.
>>
>> I have neither violated your copyright nor copied your idea (incorrectly
>> or otherwise).  If H is called that does not have P as its direct input
>> then it will still fork the simulation is at is being called within the
>> simulation and it will still decide P correctly if P terminates.
>>
>> /Flibble
>>
>
> You never stated that additional qualification before and only did so on
> the basis of my critique, thus both copyright violation and plagiarism.
> You simply copied my work verbatim (one name was changed).
>
> void P(u32 x)
> {
>   if (H(x, x))
>     HERE: goto HERE;
>   return;
> }

This code has no "Artistic" attributes, and thus in not copyrightable.

It is basically the same code as shown in the older theories and proofs,
so is not a new creation.

>
> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>
>
> and then applied the later enhancement to my work that takes
> typedef void (*ptr)();
> instead of u32.
>
> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
>
>
>
>
>

Your attempts to make these claims, if anything, dilutes your ability to
try to make any ACTUAL claims of infringement on other parts that might
be original.

On 9/24/2022 12:02 PM, Mr Flibble wrote:
> On Sat, 24 Sep 2022 08:29:47 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> On 9/24/2022 7:45 AM, Mr Flibble wrote:
>>> Hi!
>>>
>>> (N.B. I will continue to boast about this important original
>>> solution to the halting problem until all of you stop engaging with
>>> Olcott and his non-solution to the halting problem.)
>> If my rebuttal to the halting problem proofs was incorrect then at
>> least one person could correctly point out an error. So far no one
>> has done that. Many people did point out their own false assumptions
>> though.
>>
>>> 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;
>>> }

*Here is a copy of my function dating back before any of your versions*

On 4/15/2022 1:33 PM, olcott wrote:
> void P(u32 x)
> {
> if (H(x, x)) //
> HERE: goto HERE;
> }

(a) Three of the names are identical.
(b) The structure is identical.
(c) You added the same "return" instruction that I added.
(d) You converted the u32 x parameter to void function pointer as I have.

You copied my work verbatim, then applied the exact same adaptations to
my work that I applied, and only changed the name of the loop.

*A court of law would construe this as copyright violation*
*Cease and desist violating my copyright*

--
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 9/24/22 1:46 PM, olcott wrote:
> On 9/24/2022 12:02 PM, Mr Flibble wrote:
>> On Sat, 24 Sep 2022 08:29:47 -0500
>> olcott <polcott2@gmail.com> wrote:
>>
>>> On 9/24/2022 7:45 AM, Mr Flibble wrote:
>>>> Hi!
>>>>
>>>> (N.B. I will continue to boast about this important original
>>>> solution to the halting problem until all of you stop engaging with
>>>> Olcott and his non-solution to the halting problem.)
>>> If my rebuttal to the halting problem proofs was incorrect then at
>>> least one person could correctly point out an error. So far no one
>>> has done that. Many people did point out their own false assumptions
>>> though.
>>>
>>>> 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;
>>>> }
>
>
> *Here is a copy of my function dating back before any of your versions*
>
> On 4/15/2022 1:33 PM, olcott wrote:
> > void P(u32 x)
> > {
> >    if (H(x, x)) //
> >      HERE: goto HERE;
> > }
>
> (a) Three of the names are identical.
> (b) The structure is identical.
> (c) You added the same "return" instruction that I added.
> (d) You converted the u32 x parameter to void function pointer as I have.
>
> You copied my work verbatim, then applied the exact same adaptations to
> my work that I applied, and only changed the name of the loop.
>
> *A court of law would construe this as copyright violation*
> *Cease and desist violating my copyright*
>

No, they wouldn't, as your code isn't unique from prior published
versions of this code.

Your claims of copyright on things that are simple mechanical
modifiacatios of things that are already well known actually weaken you
ability to make claims on the parts that are truely new.

On 9/24/2022 12:49 PM, Richard Damon wrote:
> On 9/24/22 1:46 PM, olcott wrote:
>> On 9/24/2022 12:02 PM, Mr Flibble wrote:
>>> On Sat, 24 Sep 2022 08:29:47 -0500
>>> olcott <polcott2@gmail.com> wrote:
>>>
>>>> On 9/24/2022 7:45 AM, Mr Flibble wrote:
>>>>> Hi!
>>>>>
>>>>> (N.B. I will continue to boast about this important original
>>>>> solution to the halting problem until all of you stop engaging with
>>>>> Olcott and his non-solution to the halting problem.)
>>>> If my rebuttal to the halting problem proofs was incorrect then at
>>>> least one person could correctly point out an error. So far no one
>>>> has done that. Many people did point out their own false assumptions
>>>> though.
>>>>
>>>>> 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;
>>>>> }
>>
>>
>> *Here is a copy of my function dating back before any of your versions*
>>
>> On 4/15/2022 1:33 PM, olcott wrote:
>>  > void P(u32 x)
>>  > {
>>  >    if (H(x, x)) //
>>  >      HERE: goto HERE;
>>  > }
>>
>> (a) Three of the names are identical.
>> (b) The structure is identical.
>> (c) You added the same "return" instruction that I added.
>> (d) You converted the u32 x parameter to void function pointer as I have.
>>
>> You copied my work verbatim, then applied the exact same adaptations
>> to my work that I applied, and only changed the name of the loop.
>>
>> *A court of law would construe this as copyright violation*
>> *Cease and desist violating my copyright*
>>
>
> No, they wouldn't, as your code isn't unique from prior published
> versions of this code.

That I proved that Flibble copied my work verbatim proves copyright
infringement even though there are many similar works. None of these
similar works have nearly the same combination of identical elements
that Flibble copied.

--
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 9/24/22 2:15 PM, olcott wrote:
> On 9/24/2022 12:49 PM, Richard Damon wrote:
>> On 9/24/22 1:46 PM, olcott wrote:
>>> On 9/24/2022 12:02 PM, Mr Flibble wrote:
>>>> On Sat, 24 Sep 2022 08:29:47 -0500
>>>> olcott <polcott2@gmail.com> wrote:
>>>>
>>>>> On 9/24/2022 7:45 AM, Mr Flibble wrote:
>>>>>> Hi!
>>>>>>
>>>>>> (N.B. I will continue to boast about this important original
>>>>>> solution to the halting problem until all of you stop engaging with
>>>>>> Olcott and his non-solution to the halting problem.)
>>>>> If my rebuttal to the halting problem proofs was incorrect then at
>>>>> least one person could correctly point out an error. So far no one
>>>>> has done that. Many people did point out their own false assumptions
>>>>> though.
>>>>>
>>>>>> 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;
>>>>>> }
>>>
>>>
>>> *Here is a copy of my function dating back before any of your versions*
>>>
>>> On 4/15/2022 1:33 PM, olcott wrote:
>>>  > void P(u32 x)
>>>  > {
>>>  >    if (H(x, x)) //
>>>  >      HERE: goto HERE;
>>>  > }
>>>
>>> (a) Three of the names are identical.
>>> (b) The structure is identical.
>>> (c) You added the same "return" instruction that I added.
>>> (d) You converted the u32 x parameter to void function pointer as I
>>> have.
>>>
>>> You copied my work verbatim, then applied the exact same adaptations
>>> to my work that I applied, and only changed the name of the loop.
>>>
>>> *A court of law would construe this as copyright violation*
>>> *Cease and desist violating my copyright*
>>>
>>
>> No, they wouldn't, as your code isn't unique from prior published
>> versions of this code.
>
> That I proved that Flibble copied my work verbatim proves copyright
> infringement even though there are many similar works. None of these
> similar works have nearly the same combination of identical elements
> that Flibble copied.
>
>

Except that you don't have "Copyright" on that material, becaue YOU
essentially copied it from a prior work, you can only have copyright on
material that you put *significant* artistic effort into.

By trying to claim copyright on work you don't actually have copyright
on, you put your actual original material into jeopardy, due to dilution
of your notice of copyright.

On 9/24/2022 1:33 PM, Richard Damon wrote:
> On 9/24/22 2:15 PM, olcott wrote:
>> On 9/24/2022 12:49 PM, Richard Damon wrote:
>>> On 9/24/22 1:46 PM, olcott wrote:
>>>> On 9/24/2022 12:02 PM, Mr Flibble wrote:
>>>>> On Sat, 24 Sep 2022 08:29:47 -0500
>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>
>>>>>> On 9/24/2022 7:45 AM, Mr Flibble wrote:
>>>>>>> Hi!
>>>>>>>
>>>>>>> (N.B. I will continue to boast about this important original
>>>>>>> solution to the halting problem until all of you stop engaging with
>>>>>>> Olcott and his non-solution to the halting problem.)
>>>>>> If my rebuttal to the halting problem proofs was incorrect then at
>>>>>> least one person could correctly point out an error. So far no one
>>>>>> has done that. Many people did point out their own false assumptions
>>>>>> though.
>>>>>>
>>>>>>> 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;
>>>>>>> }
>>>>
>>>>
>>>> *Here is a copy of my function dating back before any of your versions*
>>>>
>>>> On 4/15/2022 1:33 PM, olcott wrote:
>>>>  > void P(u32 x)
>>>>  > {
>>>>  >    if (H(x, x)) //
>>>>  >      HERE: goto HERE;
>>>>  > }
>>>>
>>>> (a) Three of the names are identical.
>>>> (b) The structure is identical.
>>>> (c) You added the same "return" instruction that I added.
>>>> (d) You converted the u32 x parameter to void function pointer as I
>>>> have.
>>>>
>>>> You copied my work verbatim, then applied the exact same adaptations
>>>> to my work that I applied, and only changed the name of the loop.
>>>>
>>>> *A court of law would construe this as copyright violation*
>>>> *Cease and desist violating my copyright*
>>>>
>>>
>>> No, they wouldn't, as your code isn't unique from prior published
>>> versions of this code.
>>
>> That I proved that Flibble copied my work verbatim proves copyright
>> infringement even though there are many similar works. None of these
>> similar works have nearly the same combination of identical elements
>> that Flibble copied.
>>
>>
>
> Except that you don't have "Copyright" on that material, becasue YOU
> essentially copied it from a prior work,

The fact the Flibble's copy of my work is verbatim puts him in violation.

--
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 9/24/22 2:40 PM, olcott wrote:
> On 9/24/2022 1:33 PM, Richard Damon wrote:
>> On 9/24/22 2:15 PM, olcott wrote:
>>> On 9/24/2022 12:49 PM, Richard Damon wrote:
>>>> On 9/24/22 1:46 PM, olcott wrote:
>>>>> On 9/24/2022 12:02 PM, Mr Flibble wrote:
>>>>>> On Sat, 24 Sep 2022 08:29:47 -0500
>>>>>> olcott <polcott2@gmail.com> wrote:
>>>>>>
>>>>>>> On 9/24/2022 7:45 AM, Mr Flibble wrote:
>>>>>>>> Hi!
>>>>>>>>
>>>>>>>> (N.B. I will continue to boast about this important original
>>>>>>>> solution to the halting problem until all of you stop engaging with
>>>>>>>> Olcott and his non-solution to the halting problem.)
>>>>>>> If my rebuttal to the halting problem proofs was incorrect then at
>>>>>>> least one person could correctly point out an error. So far no one
>>>>>>> has done that. Many people did point out their own false assumptions
>>>>>>> though.
>>>>>>>
>>>>>>>> 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;
>>>>>>>> }
>>>>>
>>>>>
>>>>> *Here is a copy of my function dating back before any of your
>>>>> versions*
>>>>>
>>>>> On 4/15/2022 1:33 PM, olcott wrote:
>>>>>  > void P(u32 x)
>>>>>  > {
>>>>>  >    if (H(x, x)) //
>>>>>  >      HERE: goto HERE;
>>>>>  > }
>>>>>
>>>>> (a) Three of the names are identical.
>>>>> (b) The structure is identical.
>>>>> (c) You added the same "return" instruction that I added.
>>>>> (d) You converted the u32 x parameter to void function pointer as I
>>>>> have.
>>>>>
>>>>> You copied my work verbatim, then applied the exact same
>>>>> adaptations to my work that I applied, and only changed the name of
>>>>> the loop.
>>>>>
>>>>> *A court of law would construe this as copyright violation*
>>>>> *Cease and desist violating my copyright*
>>>>>
>>>>
>>>> No, they wouldn't, as your code isn't unique from prior published
>>>> versions of this code.
>>>
>>> That I proved that Flibble copied my work verbatim proves copyright
>>> infringement even though there are many similar works. None of these
>>> similar works have nearly the same combination of identical elements
>>> that Flibble copied.
>>>
>>>
>>
>> Except that you don't have "Copyright" on that material, becasue YOU
>> essentially copied it from a prior work,
>
> The fact the Flibble's copy of my work is verbatim puts him in violation.
>
>

First, it isn't.

His uses a void(*)() pointer, uses used a u32 (you later adopted input
form OTHERS that made it of this type, so you don't own that change).

Second, you only have copyright on something that has enugh artistic
expression to be eligable. You code is basically a copy of previous
work, so you have no copyright on it, as there is no significant
creative material in it.

There is also the concept of "Fair Use" which allows for broad use in
"eductional" contexts, which this seems to fall into.

Maybe you should look into the actual laws on Copyright.

But then, considering how badly you seem to not understand the halting
problem, understanding Copyright law is probably well beyound you.

On 9/24/22 2:40 PM, olcott wrote:

> The fact the Flibble's copy of my work is verbatim puts him in violation.
>
>

I will also point out that you problably don't want to get into a
copyright battle, as you seem to be clearly in violation of the
copyright laws with your hosting of copies of commercial material that
is likely still under copyright.

Hard to assert copyright claims on material that is derived from your
own violation of copyright.

On Sat, 24 Sep 2022 12:46:20 -0500
olcott <polcott2@gmail.com> wrote:

> On 9/24/2022 12:02 PM, Mr Flibble wrote:
> > On Sat, 24 Sep 2022 08:29:47 -0500
> > olcott <polcott2@gmail.com> wrote:
> >
> >> On 9/24/2022 7:45 AM, Mr Flibble wrote:
> >>> Hi!
> >>>
> >>> (N.B. I will continue to boast about this important original
> >>> solution to the halting problem until all of you stop engaging
> >>> with Olcott and his non-solution to the halting problem.)
> >> If my rebuttal to the halting problem proofs was incorrect then at
> >> least one person could correctly point out an error. So far no one
> >> has done that. Many people did point out their own false
> >> assumptions though.
> >>
> >>> 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;
> >>> }
>
>
> *Here is a copy of my function dating back before any of your
> versions*
>
> On 4/15/2022 1:33 PM, olcott wrote:
> > void P(u32 x)
> > {
> > if (H(x, x)) //
> > HERE: goto HERE;
> > }
>
> (a) Three of the names are identical.
> (b) The structure is identical.
> (c) You added the same "return" instruction that I added.
> (d) You converted the u32 x parameter to void function pointer as I
> have.
>
> You copied my work verbatim, then applied the exact same adaptations
> to my work that I applied, and only changed the name of the loop.
>
> *A court of law would construe this as copyright violation*
> *Cease and desist violating my copyright*

I haven't violated your copyright; also, you cannot copyright an idea.

/Flibble

On Sat, 24 Sep 2022 12:46:20 -0500
olcott <polcott2@gmail.com> wrote:

> On 9/24/2022 12:02 PM, Mr Flibble wrote:
> > On Sat, 24 Sep 2022 08:29:47 -0500
> > olcott <polcott2@gmail.com> wrote:
> >
> >> On 9/24/2022 7:45 AM, Mr Flibble wrote:
> >>> Hi!
> >>>
> >>> (N.B. I will continue to boast about this important original
> >>> solution to the halting problem until all of you stop engaging
> >>> with Olcott and his non-solution to the halting problem.)
> >> If my rebuttal to the halting problem proofs was incorrect then at
> >> least one person could correctly point out an error. So far no one
> >> has done that. Many people did point out their own false
> >> assumptions though.
> >>
> >>> 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;
> >>> }
>
>
> *Here is a copy of my function dating back before any of your
> versions*
>
> On 4/15/2022 1:33 PM, olcott wrote:
> > void P(u32 x)
> > {
> > if (H(x, x)) //
> > HERE: goto HERE;
> > }
>
> (a) Three of the names are identical.
> (b) The structure is identical.
> (c) You added the same "return" instruction that I added.
> (d) You converted the u32 x parameter to void function pointer as I
> have.

Interestingly as far as (d) is concerned I used a void function pointer
before you did so you copied me. This can be proven based on
publication dates of articles in this newsgroup and the commit date of
my GitHub repo.

/Flibble

On 9/24/2022 2:08 PM, Richard Damon wrote:
>
> On 9/24/22 2:40 PM, olcott wrote:
>
>> The fact the Flibble's copy of my work is verbatim puts him in violation.
>>
>>
>
> I will also point out that you problably don't want to get into a
> copyright battle, as you seem to be clearly in violation of the
> copyright laws with your hosting of copies of commercial material that
> is likely still under copyright.
>

The rebuttal of a formal proof allows for the full proof to be provided
under "fair use".

> Hard to assert copyright claims on material that is derived from your
> own violation of copyright.

--
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 9/24/2022 2:10 PM, Mr Flibble wrote:
> On Sat, 24 Sep 2022 12:46:20 -0500
> olcott <polcott2@gmail.com> wrote:
>
>> On 9/24/2022 12:02 PM, Mr Flibble wrote:
>>> On Sat, 24 Sep 2022 08:29:47 -0500
>>> olcott <polcott2@gmail.com> wrote:
>>>
>>>> On 9/24/2022 7:45 AM, Mr Flibble wrote:
>>>>> Hi!
>>>>>
>>>>> (N.B. I will continue to boast about this important original
>>>>> solution to the halting problem until all of you stop engaging
>>>>> with Olcott and his non-solution to the halting problem.)
>>>> If my rebuttal to the halting problem proofs was incorrect then at
>>>> least one person could correctly point out an error. So far no one
>>>> has done that. Many people did point out their own false
>>>> assumptions though.
>>>>
>>>>> 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;
>>>>> }
>>
>>
>> *Here is a copy of my function dating back before any of your
>> versions*
>>
>> On 4/15/2022 1:33 PM, olcott wrote:
>> > void P(u32 x)
>> > {
>> > if (H(x, x)) //
>> > HERE: goto HERE;
>> > }
>>
>> (a) Three of the names are identical.
>> (b) The structure is identical.
>> (c) You added the same "return" instruction that I added.
>> (d) You converted the u32 x parameter to void function pointer as I
>> have.
>>
>> You copied my work verbatim, then applied the exact same adaptations
>> to my work that I applied, and only changed the name of the loop.
>>
>> *A court of law would construe this as copyright violation*
>> *Cease and desist violating my copyright*
>
> I haven't violated your copyright; also, you cannot copyright an idea.
>
> /Flibble
>

You verbatim copy of my work is a violation of copyright.

--
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 Sat, 24 Sep 2022 15:05:06 -0500
olcott <polcott2@gmail.com> wrote:

> On 9/24/2022 2:10 PM, Mr Flibble wrote:
> > On Sat, 24 Sep 2022 12:46:20 -0500
> > olcott <polcott2@gmail.com> wrote:
> >
> >> On 9/24/2022 12:02 PM, Mr Flibble wrote:
> >>> On Sat, 24 Sep 2022 08:29:47 -0500
> >>> olcott <polcott2@gmail.com> wrote:
> >>>
> >>>> On 9/24/2022 7:45 AM, Mr Flibble wrote:
> >>>>> Hi!
> >>>>>
> >>>>> (N.B. I will continue to boast about this important original
> >>>>> solution to the halting problem until all of you stop engaging
> >>>>> with Olcott and his non-solution to the halting problem.)
> >>>> If my rebuttal to the halting problem proofs was incorrect then
> >>>> at least one person could correctly point out an error. So far
> >>>> no one has done that. Many people did point out their own false
> >>>> assumptions though.
> >>>>
> >>>>> 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;
> >>>>> }
> >>
> >>
> >> *Here is a copy of my function dating back before any of your
> >> versions*
> >>
> >> On 4/15/2022 1:33 PM, olcott wrote:
> >> > void P(u32 x)
> >> > {
> >> > if (H(x, x)) //
> >> > HERE: goto HERE;
> >> > }
> >>
> >> (a) Three of the names are identical.
> >> (b) The structure is identical.
> >> (c) You added the same "return" instruction that I added.
> >> (d) You converted the u32 x parameter to void function pointer as I
> >> have.
> >>
> >> You copied my work verbatim, then applied the exact same
> >> adaptations to my work that I applied, and only changed the name
> >> of the loop.
> >>
> >> *A court of law would construe this as copyright violation*
> >> *Cease and desist violating my copyright*
> >
> > I haven't violated your copyright; also, you cannot copyright an
> > idea.
> >
> > /Flibble
> >
>
> You verbatim copy of my work is a violation of copyright.

I have not made a verbatim copy of your work and my idea bears no
relation to your idea whatsoever: my idea works, yours doesn't.

/Flibble

On 9/24/22 4:04 PM, olcott wrote:
> On 9/24/2022 2:08 PM, Richard Damon wrote:
>>
>> On 9/24/22 2:40 PM, olcott wrote:
>>
>>> The fact the Flibble's copy of my work is verbatim puts him in
>>> violation.
>>>
>>>
>>
>> I will also point out that you problably don't want to get into a
>> copyright battle, as you seem to be clearly in violation of the
>> copyright laws with your hosting of copies of commercial material that
>> is likely still under copyright.
>>
>
> The rebuttal of a formal proof allows for the full proof to be provided
> under "fair use".

No, not the way you do it, as an INDEPENDENT document on your site.

Maybe someone should point out to the publisher your site and get a
take-down issued.

Note, you CAN include a copy of that material interspersed with your
arguements about it, THAT is fair use.

Note, Your writting are not a "Rebuttal", as no where do you point out
an actual factual error in the writting. You just claim that by
considering ALL Halt Deciders, he doesn't consider the SUB-SET of
Simulationg Halt Deciders.

It seems you don't dare put your actual "proof" too close to the
original writing as it becomes clear that you aren't doing what the
proof actually says you need to do.

You are just trying to come up with a counter example that defies the
proof (which just proves the logic you use is incosistent).

I will also note that your counter example is totally invalid, as the
THEOREM (routhly stated) is that you can't create a Halt Decider, that
when given a description and its input predicts what that machine would
do. Thus H(P,d) will return 1 if P(d) returns an answer, and 0 if P(d)
will NEVER return an answer no matter how many steps it is run.

Your counter is an H that you claim is corret about H(P,P) by returning
0 even though you admit that P(P) Halts, because that isn't the behavior
of its input. You claim this on the basis that "The behavior of the
input" to H(P,P) is different than the behavior of P(P), but that is
irrelevent, as the problem is SPECCIFICALY about the behavior of the
starting machine (the P(P)). All you are doing is proving that you don't
understand what the actual problem talks about.

>
>> Hard to assert copyright claims on material that is derived from your
>> own violation of copyright.
>

On 9/24/2022 3:39 PM, Richard Damon wrote:
> On 9/24/22 4:04 PM, olcott wrote:
>> On 9/24/2022 2:08 PM, Richard Damon wrote:
>>>
>>> On 9/24/22 2:40 PM, olcott wrote:
>>>
>>>> The fact the Flibble's copy of my work is verbatim puts him in
>>>> violation.
>>>>
>>>>
>>>
>>> I will also point out that you problably don't want to get into a
>>> copyright battle, as you seem to be clearly in violation of the
>>> copyright laws with your hosting of copies of commercial material
>>> that is likely still under copyright.
>>>
>>
>> The rebuttal of a formal proof allows for the full proof to be
>> provided under "fair use".
>
> No, not the way you do it, as an INDEPENDENT document on your site.
>
> Maybe someone should point out to the publisher your site and get a
> take-down issued.
>
> Note, you CAN include a copy of that material interspersed with your
> arguements about it, THAT is fair use.
>

It works as an appendix, yet does not work as interspersed. My rebuttal
to the proof is within the context that the whole Linz proof is already
in your mind.

> Note, Your writting are not a "Rebuttal", as no where do you point out
> an actual factual error in the writting. You just claim that by
> considering ALL Halt Deciders, he doesn't consider the SUB-SET of
> Simulationg Halt Deciders.

Which means that no one ever bothered to notice that the correctly
simulated input to the embedded copy of Linz H cannot reach its own
final state in 1 to ∞ correctly simulated steps. This proves that this
input specifies a non-halting sequence of configurations to every
simulating halt decider.

--
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 9/24/22 5:31 PM, olcott wrote:
> On 9/24/2022 3:39 PM, Richard Damon wrote:
>> On 9/24/22 4:04 PM, olcott wrote:
>>> On 9/24/2022 2:08 PM, Richard Damon wrote:
>>>>
>>>> On 9/24/22 2:40 PM, olcott wrote:
>>>>
>>>>> The fact the Flibble's copy of my work is verbatim puts him in
>>>>> violation.
>>>>>
>>>>>
>>>>
>>>> I will also point out that you problably don't want to get into a
>>>> copyright battle, as you seem to be clearly in violation of the
>>>> copyright laws with your hosting of copies of commercial material
>>>> that is likely still under copyright.
>>>>
>>>
>>> The rebuttal of a formal proof allows for the full proof to be
>>> provided under "fair use".
>>
>> No, not the way you do it, as an INDEPENDENT document on your site.
>>
>> Maybe someone should point out to the publisher your site and get a
>> take-down issued.
>>
>> Note, you CAN include a copy of that material interspersed with your
>> arguements about it, THAT is fair use.
>>
>
> It works as an appendix, yet does not work as interspersed. My rebuttal
> to the proof is within the context that the whole Linz proof is already
> in your mind.
>

When you have it as an appendix that is PART of the document, that is
fine, but you have chapters just as PDF on your liar web-site which is
the copyright violations.

Those are NOT part of a critical work commentating on them.

>> Note, Your writting are not a "Rebuttal", as no where do you point out
>> an actual factual error in the writting. You just claim that by
>> considering ALL Halt Deciders, he doesn't consider the SUB-SET of
>> Simulationg Halt Deciders.
>
> Which means that no one ever bothered to notice that the correctly
> simulated input to the embedded copy of Linz H cannot reach its own
> final state in 1 to ∞ correctly simulated steps. This proves that this
> input specifies a non-halting sequence of configurations to every
> simulating halt decider.
>

No, the problem is that it isn't the simulation tha H does that matters,

H is being asked about the independent running of the machine specified
as an input.

If you want to claim that it can't answer about that machine, that is
just CONFIRMING the Theorem, as the Theorem is about making a decider to
decide on that independent machine.

Remember, the DEFINITION is:

H applied to <M> x must go to Qy if M applied to x will halt,
and to Qn if M applied to x will never halt.

No mention about the behavior of the simulated input.

Yes, we can replace M applied to x with UTM applied to <M> x, but that
still is looking at the simulation done by an ACTUAL UTM, not H.

H can NOT be a UTM, as BY DEFINITION, if it was, it could not answer for
a non-halting inpt, and thus if fails to be a decider.

Mr Flibble <flibble@reddwarf.jmc.corp> writes:

> (N.B. I will continue to boast about this

That's refreshing. Only three weeks ago you flatly denied you were
boasting!

--
Ben.

On Saturday, September 24, 2022 at 6:50:12 PM UTC-7, Ben Bacarisse wrote:
> Mr Flibble <fli...@reddwarf.jmc.corp> writes:
>
> > (N.B. I will continue to boast about this
> That's refreshing. Only three weeks ago you flatly denied you were
> boasting!
>
> --
> Ben.

"Flibble"?
"It's like FUD."
"Oh."

Jeffrey Rubard <jeffreydanielrubard@gmail.com> writes:

> "Flibble"?
> "It's like FUD."
> "Oh."

Shhh! They are talking to each other...

<tiptoes away...>

--
Ben.