On 6/26/2021 10:06 AM, Richard Damon wrote:
> On 6/26/21 10:55 AM, olcott wrote:
>> On 6/26/2021 5:32 AM, Richard Damon wrote:
>>> On 6/25/21 11:07 PM, olcott wrote:
>>>> On 6/25/2021 9:07 PM, Richard Damon wrote:
>>>>> On 6/25/21 9:46 PM, olcott wrote:
>>>>>> On 6/25/2021 8:37 PM, Richard Damon wrote:
>>>>>>> On 6/25/21 9:01 PM, olcott wrote:
>>>>>>>> On 6/25/2021 7:40 PM, Richard Damon wrote:
>>>>>>>>> On 6/25/21 6:56 PM, olcott wrote:
>>>>>>>>>> On 6/25/2021 4:59 PM, Richard Damon wrote:
>>>>>>>>>>> On 6/25/21 4:40 PM, olcott wrote:
>>>>>>>>>>>> On 6/25/2021 3:11 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 6/25/21 2:50 PM, olcott wrote:
>>>>>>>>>>>>>> On 6/25/2021 12:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> WRONG. P is DEFINED based on H. If you Hypothetically create
>>>>>>>>>>>>>>> a P
>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>> doesn't follow that form, then you are hypothetically
>>>>>>>>>>>>>>> creating
>>>>>>>>>>>>>>> nonsense
>>>>>>>>>>>>>>> and can't use it to for anything logical.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Of every possible encoding of simulating partial halt
>>>>>>>>>>>>>> decider H
>>>>>>>>>>>>>> that can
>>>>>>>>>>>>>> possibly exist  H*, if H* never aborts the simulation of its
>>>>>>>>>>>>>> input
>>>>>>>>>>>>>> results in the infinite execution of the invocation of of P(P)
>>>>>>>>>>>>>> then a
>>>>>>>>>>>>>> simulating halt decider H that does abort its simulation of
>>>>>>>>>>>>>> this
>>>>>>>>>>>>>> input
>>>>>>>>>>>>>> does correctly decide that this input does specify the never
>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>> behavior of an infinite chain of invocations.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes, if H* is an element of the set of non-aborting deciders
>>>>>>>>>>>>> (Hn), P
>>>>>>>>>>>>> will result in infinite recursion,
>>>>>>>>>>>>
>>>>>>>>>>>> Which logically entails beyond all possible doubt that the
>>>>>>>>>>>> set of
>>>>>>>>>>>> encodings of simulating partial halt deciders H2* that do abort
>>>>>>>>>>>> the
>>>>>>>>>>>> simulation of the (P,P) input would correctly report that this
>>>>>>>>>>>> input
>>>>>>>>>>>> never halts.
>>>>>>>>>>>
>>>>>>>>>>> WHY?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Axiom(1) Every computation that never halts unless its
>>>>>>>>>> simulation is
>>>>>>>>>> aborted is a computation that never halts. This verified as
>>>>>>>>>> true on
>>>>>>>>>> the
>>>>>>>>>> basis of the meaning of its words.
>>>>>>>>>
>>>>>>>>> WRONG.
>>>>>>>>>
>>>>>>>>> Your test does not match the plain meaning of the words, as has
>>>>>>>>> been
>>>>>>>>> explained many times.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Those words may be over your head, yet several others understand
>>>>>>>> that
>>>>>>>> they are necessarily correct.
>>>>>>>
>>>>>>> I have seen NO ONE agree to your interpretation of it. The plain
>>>>>>> meaning
>>>>>>> is that if it can be shown that if the given instance of the
>>>>>>> simulator
>>>>>>> simulating a given input doesn't stop its simulation that this
>>>>>>> simulation will run forevr, then the machine that is being simulated
>>>>>>> can
>>>>>>> be corrected decided as non-Halting.
>>>>>>>
>>>>>>> An more formal way to say that is if UTM(P,I) is non-halting then
>>>>>>> it is
>>>>>>> correct for H(P,I) to return the non-halting result.
>>>>>>>
>>>>>>> This actually follows since UTM(P,I) will be non-halting if and
>>>>>>> only if
>>>>>>> P(I) is non-halting by the definition of a UTM, so that statement is
>>>>>>> trivially proven.
>>>>>>>
>>>>>>> Your interpretation, where even if a copy of the algorithm of H is
>>>>>>> included in P and that included copy needs to abort the simulation of
>>>>>>> the copy of the machine that it was given, can be PROVEN wrong, as
>>>>>>> even
>>>>>>> you have shown that P(P) in this case does Halt, thus your claimed
>>>>>>> correct answer is wrong by the definition of the problem.
>>>>>>>
>>>>>>> Only if you define that your answer isn't actually supposed to be the
>>>>>>> answer to the halting problem can you justify your answer to be
>>>>>>> correct,
>>>>>>> but then you proof doesn't achieve the goal you claim.
>>>>>>>
>>>>>>>>
>>>>>>>>> Note, it is easy to show that your interpretation is wrong since
>>>>>>>>> even
>>>>>>>>> you admit that Linz H^, now called P by you will come to its end
>>>>>>>>> and
>>>>>>>>> halt when given it own representation as its input, and thus is BY
>>>>>>>>> DEFINITION a Halting Computation, Thus the H deciding it didn't
>>>>>>>>> need to
>>>>>>>>> abort its execution to get the wrong answer of Non-Halting.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Because at least one invocation of the infinite invocation chain
>>>>>>>> specified by P(P) had to be terminated to prevent the infinite
>>>>>>>> execution
>>>>>>>> of this infinite invocation chain it is confirmed beyond all
>>>>>>>> possible
>>>>>>>> doubt that P(P) specifies an invocation chain.
>>>>>>>
>>>>>>> WRONG. Given that we have an H that can answer H(P,P) because it
>>>>>>> knows
>>>>>>> at least enough to terminate the pattern you describe, then when
>>>>>>> we run
>>>>>>> P(P) then because the H within it also knows to abort this sequence
>>>>>>> (since it is built on the same algorithm) this P is NOT part of an
>>>>>>> infinite chain of execution, and thus its H can return its (wrong)
>>>>>>> answer to it and that P can then Halt.
>>>>>>
>>>>>> P(P) specifies in infinite invocation sequence that is terminated
>>>>>> on its
>>>>>> third invocation of H(P,P).
>>>>>>
>>>>>> P(P) specifies in infinite invocation sequence that is terminated
>>>>>> on its
>>>>>> third invocation of H(P,P).
>>>>>>
>>>>>> P(P) specifies in infinite invocation sequence that is terminated
>>>>>> on its
>>>>>> third invocation of H(P,P).
>>>>>>
>>>>>> P(P) specifies in infinite invocation sequence that is terminated
>>>>>> on its
>>>>>> third invocation of H(P,P).
>>>>>>
>>>>>> P(P) specifies in infinite invocation sequence that is terminated
>>>>>> on its
>>>>>> third invocation of H(P,P).
>>>>>>
>>>>>> Now I have told this this several hundred times.
>>>>>>
>>>>>>
>>>>>
>>>>> WRONG.
>>>>>
>>>>> P(P) starts.
>>>>>
>>>>> Calls H(P,P)
>>>>>
>>>>> H starts the simulation.
>>>>>
>>>>> H simulates P starting
>>>>>
>>>>> H simulates P calling H
>>>>>
>>>>> H simulates H starting its simulation
>>>>>
>>>>> H simulates H simulating P starting
>>>>>
>>>>> H simulates H simulating P calling H
>>>>>
>>>>> The first H about here detects what it THINKS is an infinite execution
>>>>>
>>>>> THe first H aborts its simulation
>>>>>
>>>>> The first H returns its answer (Non-Halting) to its caller
>>>>>
>>>>> P then Halts
>>>>>
>>>>> Showing P is a Halting Computation.
>>>>
>>>> As you already admitted P ONLY halts because some H aborts some P
>>>> otherwise P never ever halts.
>>>>
>>>> As you already admitted P ONLY halts because some H aborts some P
>>>> otherwise P never ever halts.
>>>>
>>>> As you already admitted P ONLY halts because some H aborts some P
>>>> otherwise P never ever halts.
>>>>
>>>> As you already admitted P ONLY halts because some H aborts some P
>>>> otherwise P never ever halts.
>>>>
>>>> As you already admitted P ONLY halts because some H aborts some P
>>>> otherwise P never ever halts.
>>>>
>>>
>>> Yes, P halts because the H it contains terminated the simulation of
>>> another copy of its description.
>>>
>>> YOUR problem is that you think that actually means something, it doesn't
>>>
>>
>> Whenever one invocation of the infinite invocation chain of infinite
>> recursion is aborted the whole chain terminates.
>
> WRONG, if the aborting is occurring inside the chain, which it is in
> this case.
>

strong color theorem: most regular graphs of degree d squared are d + one colorable.

On 6/26/21 11:52 AM, olcott wrote:
> On 6/26/2021 9:51 AM, Ben Bacarisse wrote:
>> I've trimmed the newsgroups.  I suggest everyone else does so as well.
>> There is no need to damage more than one group with this junk.
>>
>> Jeff Barnett <jbb@notatt.com> writes:
>>
>>> On 6/26/2021 2:11 AM, Chris M. Thomasson wrote:
>>>> Are you nuts, or are recovering from a recent head injury?
>>>
>>> It's not recent. It seems he's been at it for a few decades.
>>
>> I first cam across PO when he was about to get rich selling some
>> software based on two junk patents he'd filed.  The software was vapour
>> ware (at the time) but the expectation of riches was real enough.  The
>> situation may be reversed now.
>>
>> I appear to have first talked about halting with PO in 2012.  I had a
>> look at one of the replies I made back then.  See how predictable it all
>> is:
>>
>>    "You see?  No connection to what I said.  No discussion.  Just a
>>    re-statement of the same false claim.  Should I state, yet again, why
>>    it's false?  Is there any reason to think you'd address the argument
>>    if I did so?"
>>
>> That's a shade off 20 years ago.  It really is futile.
>>
>
> On 10/17/2006 7:03 PM, Ben Bacarisse wrote:
>> "Peter Olcott" <NoSpam@SeeScreen.com> writes:
>
> It is the case that P(P) has infinite execution unless one its infinite
> chain of invocations is aborted.
>
> You know there is no rebuttal to this because it is an easily verifiable
> fact, even Richard acknowledged that P(P) never halts

Right, IF H doesn't abort P then P in non-halting.

That does NOT mean that if H does abort a DIFFERENT P (since changing H
changes P) that this different P is also non-halting.

More clearly stated:

Given Hn, which doesn't abort its simulation of Pn(Pn), then we can show
that Pn(Pn) is non-Halting.

But, when we look at Ha, that does abort its simuation, while we can
show that Ha is correct in deciding Pn(Pn) as non-halting, it does NOT
imply that Ha deciding that Pa(Pa) as non-Halting is correct, and in
fact we can show that Pa(Pa) will be Halting, and thus we can PROVE that
Ha is WRONG in deciding that Pa(Pa) is non-halting.

Failure to keep your differing machines distinct.

>
> On 6/25/2021 3:11 PM, Richard Damon wrote:
>>
>> Yes, if H* is an element of the set of non-aborting deciders (Hn), P
>> will result in infinite recursion,
>
> So you will misdirect with ad hominem and rhetoric because you know that
> there is no plausible rebuttal using logic.
>

As I said above, this shows that the P made from the non-aborting
decider is non-halting because it gets into an infintie loop. But that
is ok, as that H also never answerss.

Once you make your H be able to abort its simulation, the P that we get
from that no longer has this problem. You just seem unable to keep this
straight.

On 6/26/21 12:00 PM, olcott wrote:
> On 6/26/2021 10:06 AM, Richard Damon wrote:
>> On 6/26/21 10:55 AM, olcott wrote:
>>> On 6/26/2021 5:32 AM, Richard Damon wrote:
>>>> On 6/25/21 11:07 PM, olcott wrote:
>>>>> On 6/25/2021 9:07 PM, Richard Damon wrote:
>>>>>> On 6/25/21 9:46 PM, olcott wrote:
>>>>>>> On 6/25/2021 8:37 PM, Richard Damon wrote:
>>>>>>>> On 6/25/21 9:01 PM, olcott wrote:
>>>>>>>>> On 6/25/2021 7:40 PM, Richard Damon wrote:
>>>>>>>>>> On 6/25/21 6:56 PM, olcott wrote:
>>>>>>>>>>> On 6/25/2021 4:59 PM, Richard Damon wrote:
>>>>>>>>>>>> On 6/25/21 4:40 PM, olcott wrote:
>>>>>>>>>>>>> On 6/25/2021 3:11 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 6/25/21 2:50 PM, olcott wrote:
>>>>>>>>>>>>>>> On 6/25/2021 12:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> WRONG. P is DEFINED based on H. If you Hypothetically
>>>>>>>>>>>>>>>> create
>>>>>>>>>>>>>>>> a P
>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>> doesn't follow that form, then you are hypothetically
>>>>>>>>>>>>>>>> creating
>>>>>>>>>>>>>>>> nonsense
>>>>>>>>>>>>>>>> and can't use it to for anything logical.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Of every possible encoding of simulating partial halt
>>>>>>>>>>>>>>> decider H
>>>>>>>>>>>>>>> that can
>>>>>>>>>>>>>>> possibly exist  H*, if H* never aborts the simulation of its
>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>> results in the infinite execution of the invocation of of
>>>>>>>>>>>>>>> P(P)
>>>>>>>>>>>>>>> then a
>>>>>>>>>>>>>>> simulating halt decider H that does abort its simulation of
>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>> does correctly decide that this input does specify the never
>>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>>> behavior of an infinite chain of invocations.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes, if H* is an element of the set of non-aborting deciders
>>>>>>>>>>>>>> (Hn), P
>>>>>>>>>>>>>> will result in infinite recursion,
>>>>>>>>>>>>>
>>>>>>>>>>>>> Which logically entails beyond all possible doubt that the
>>>>>>>>>>>>> set of
>>>>>>>>>>>>> encodings of simulating partial halt deciders H2* that do
>>>>>>>>>>>>> abort
>>>>>>>>>>>>> the
>>>>>>>>>>>>> simulation of the (P,P) input would correctly report that this
>>>>>>>>>>>>> input
>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>
>>>>>>>>>>>> WHY?
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Axiom(1) Every computation that never halts unless its
>>>>>>>>>>> simulation is
>>>>>>>>>>> aborted is a computation that never halts. This verified as
>>>>>>>>>>> true on
>>>>>>>>>>> the
>>>>>>>>>>> basis of the meaning of its words.
>>>>>>>>>>
>>>>>>>>>> WRONG.
>>>>>>>>>>
>>>>>>>>>> Your test does not match the plain meaning of the words, as has
>>>>>>>>>> been
>>>>>>>>>> explained many times.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Those words may be over your head, yet several others understand
>>>>>>>>> that
>>>>>>>>> they are necessarily correct.
>>>>>>>>
>>>>>>>> I have seen NO ONE agree to your interpretation of it. The plain
>>>>>>>> meaning
>>>>>>>> is that if it can be shown that if the given instance of the
>>>>>>>> simulator
>>>>>>>> simulating a given input doesn't stop its simulation that this
>>>>>>>> simulation will run forevr, then the machine that is being
>>>>>>>> simulated
>>>>>>>> can
>>>>>>>> be corrected decided as non-Halting.
>>>>>>>>
>>>>>>>> An more formal way to say that is if UTM(P,I) is non-halting then
>>>>>>>> it is
>>>>>>>> correct for H(P,I) to return the non-halting result.
>>>>>>>>
>>>>>>>> This actually follows since UTM(P,I) will be non-halting if and
>>>>>>>> only if
>>>>>>>> P(I) is non-halting by the definition of a UTM, so that
>>>>>>>> statement is
>>>>>>>> trivially proven.
>>>>>>>>
>>>>>>>> Your interpretation, where even if a copy of the algorithm of H is
>>>>>>>> included in P and that included copy needs to abort the
>>>>>>>> simulation of
>>>>>>>> the copy of the machine that it was given, can be PROVEN wrong, as
>>>>>>>> even
>>>>>>>> you have shown that P(P) in this case does Halt, thus your claimed
>>>>>>>> correct answer is wrong by the definition of the problem.
>>>>>>>>
>>>>>>>> Only if you define that your answer isn't actually supposed to
>>>>>>>> be the
>>>>>>>> answer to the halting problem can you justify your answer to be
>>>>>>>> correct,
>>>>>>>> but then you proof doesn't achieve the goal you claim.
>>>>>>>>
>>>>>>>>>
>>>>>>>>>> Note, it is easy to show that your interpretation is wrong since
>>>>>>>>>> even
>>>>>>>>>> you admit that Linz H^, now called P by you will come to its end
>>>>>>>>>> and
>>>>>>>>>> halt when given it own representation as its input, and thus
>>>>>>>>>> is BY
>>>>>>>>>> DEFINITION a Halting Computation, Thus the H deciding it didn't
>>>>>>>>>> need to
>>>>>>>>>> abort its execution to get the wrong answer of Non-Halting.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Because at least one invocation of the infinite invocation chain
>>>>>>>>> specified by P(P) had to be terminated to prevent the infinite
>>>>>>>>> execution
>>>>>>>>> of this infinite invocation chain it is confirmed beyond all
>>>>>>>>> possible
>>>>>>>>> doubt that P(P) specifies an invocation chain.
>>>>>>>>
>>>>>>>> WRONG. Given that we have an H that can answer H(P,P) because it
>>>>>>>> knows
>>>>>>>> at least enough to terminate the pattern you describe, then when
>>>>>>>> we run
>>>>>>>> P(P) then because the H within it also knows to abort this sequence
>>>>>>>> (since it is built on the same algorithm) this P is NOT part of an
>>>>>>>> infinite chain of execution, and thus its H can return its (wrong)
>>>>>>>> answer to it and that P can then Halt.
>>>>>>>
>>>>>>> P(P) specifies in infinite invocation sequence that is terminated
>>>>>>> on its
>>>>>>> third invocation of H(P,P).
>>>>>>>
>>>>>>> P(P) specifies in infinite invocation sequence that is terminated
>>>>>>> on its
>>>>>>> third invocation of H(P,P).
>>>>>>>
>>>>>>> P(P) specifies in infinite invocation sequence that is terminated
>>>>>>> on its
>>>>>>> third invocation of H(P,P).
>>>>>>>
>>>>>>> P(P) specifies in infinite invocation sequence that is terminated
>>>>>>> on its
>>>>>>> third invocation of H(P,P).
>>>>>>>
>>>>>>> P(P) specifies in infinite invocation sequence that is terminated
>>>>>>> on its
>>>>>>> third invocation of H(P,P).
>>>>>>>
>>>>>>> Now I have told this this several hundred times.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> WRONG.
>>>>>>
>>>>>> P(P) starts.
>>>>>>
>>>>>> Calls H(P,P)
>>>>>>
>>>>>> H starts the simulation.
>>>>>>
>>>>>> H simulates P starting
>>>>>>
>>>>>> H simulates P calling H
>>>>>>
>>>>>> H simulates H starting its simulation
>>>>>>
>>>>>> H simulates H simulating P starting
>>>>>>
>>>>>> H simulates H simulating P calling H
>>>>>>
>>>>>> The first H about here detects what it THINKS is an infinite
>>>>>> execution
>>>>>>
>>>>>> THe first H aborts its simulation
>>>>>>
>>>>>> The first H returns its answer (Non-Halting) to its caller
>>>>>>
>>>>>> P then Halts
>>>>>>
>>>>>> Showing P is a Halting Computation.
>>>>>
>>>>> As you already admitted P ONLY halts because some H aborts some P
>>>>> otherwise P never ever halts.
>>>>>
>>>>> As you already admitted P ONLY halts because some H aborts some P
>>>>> otherwise P never ever halts.
>>>>>
>>>>> As you already admitted P ONLY halts because some H aborts some P
>>>>> otherwise P never ever halts.
>>>>>
>>>>> As you already admitted P ONLY halts because some H aborts some P
>>>>> otherwise P never ever halts.
>>>>>
>>>>> As you already admitted P ONLY halts because some H aborts some P
>>>>> otherwise P never ever halts.
>>>>>
>>>>
>>>> Yes, P halts because the H it contains terminated the simulation of
>>>> another copy of its description.
>>>>
>>>> YOUR problem is that you think that actually means something, it
>>>> doesn't
>>>>
>>>
>>> Whenever one invocation of the infinite invocation chain of infinite
>>> recursion is aborted the whole chain terminates.
>>
>> WRONG, if the aborting is occurring inside the chain, which it is in
>> this case.
>>
>
> In the computation int main() { P(P); } If no P ever halts unless some H
> aborts some P this proves beyond all possible doubt that P(P) specifies
> an infinitely recursive chain of invocations.
>
> That it took me so long to find these words proves that I am a
> relatively terrible communicator. On the other hand these words do
> unequivocally validate that my logic was correct all along.
>

On 6/26/2021 11:08 AM, Richard Damon wrote:
> On 6/26/21 11:52 AM, olcott wrote:
>> On 6/26/2021 9:51 AM, Ben Bacarisse wrote:
>>> I've trimmed the newsgroups.  I suggest everyone else does so as well.
>>> There is no need to damage more than one group with this junk.
>>>
>>> Jeff Barnett <jbb@notatt.com> writes:
>>>
>>>> On 6/26/2021 2:11 AM, Chris M. Thomasson wrote:
>>>>> Are you nuts, or are recovering from a recent head injury?
>>>>
>>>> It's not recent. It seems he's been at it for a few decades.
>>>
>>> I first cam across PO when he was about to get rich selling some
>>> software based on two junk patents he'd filed.  The software was vapour
>>> ware (at the time) but the expectation of riches was real enough.  The
>>> situation may be reversed now.
>>>
>>> I appear to have first talked about halting with PO in 2012.  I had a
>>> look at one of the replies I made back then.  See how predictable it all
>>> is:
>>>
>>>    "You see?  No connection to what I said.  No discussion.  Just a
>>>    re-statement of the same false claim.  Should I state, yet again, why
>>>    it's false?  Is there any reason to think you'd address the argument
>>>    if I did so?"
>>>
>>> That's a shade off 20 years ago.  It really is futile.
>>>
>>
>> On 10/17/2006 7:03 PM, Ben Bacarisse wrote:
>>> "Peter Olcott" <NoSpam@SeeScreen.com> writes:
>>
>> It is the case that P(P) has infinite execution unless one its infinite
>> chain of invocations is aborted.
>>
>> You know there is no rebuttal to this because it is an easily verifiable
>> fact, even Richard acknowledged that P(P) never halts
>
> Right, IF H doesn't abort P then P in non-halting.
>
> That does NOT mean that if H does abort a DIFFERENT P (since changing H
> changes P) that this different P is also non-halting.
>

In the computation int main() { P(P); } when no P ever halts unless some
H aborts some P this proves beyond all possible doubt that P(P)
specifies an infinitely recursive chain of invocations.

The computation int main() { P(P); } calls H(P,P) which is the first
invocation of an infinite chain of invocations. Whenever P calls H(P,P)
H must abort its simulation of P.

It is common knowledge that when any invocation of an infinite sequence
of invocations (such as infinite recursion or infinitely nested
simulation) is terminated then the entire sequence halts.

In the computation int main() { P(P); } the third element of the
infinite chain of invocations is terminated. The only reason that any P
ever halts is that some H aborted some P. This proves (axiomatically)
that P(P) really does specify an infinite invocation chain.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 6/26/2021 8:51 AM, Ben Bacarisse wrote:
> I've trimmed the newsgroups. I suggest everyone else does so as well.
> There is no need to damage more than one group with this junk.
>
> Jeff Barnett <jbb@notatt.com> writes:
>
>> On 6/26/2021 2:11 AM, Chris M. Thomasson wrote:
>>> Are you nuts, or are recovering from a recent head injury?
>>
>> It's not recent. It seems he's been at it for a few decades.
>
> I first cam across PO when he was about to get rich selling some
> software based on two junk patents he'd filed. The software was vapour
> ware (at the time) but the expectation of riches was real enough. The
> situation may be reversed now.

I only know about one junk patent - a character reader. It was from
reading it that I formed the following conclusions: bad software
engineer, bad programmer, selection of ridiculous problem to invest so
much effort, made no contribution, totally unimpressive work, no value.
It was one of those software patents that was granted by a government
agency that had little clue about information technologies and in good
bureaucratic style figured the courts would sort it out if necessary.
The only software patents that are seriously reviewed are those passed
off to NSA for comments.

I also had experience with better, more advanced technology in the 1960s
where the recognition was done in realtime hand writing. Thoroughly
unimpressive work.

> I appear to have first talked about halting with PO in 2012. I had a
> look at one of the replies I made back then. See how predictable it all
> is:
>
> "You see? No connection to what I said. No discussion. Just a
> re-statement of the same false claim. Should I state, yet again, why
> it's false? Is there any reason to think you'd address the argument
> if I did so?"
>
> That's a shade off 20 years ago. It really is futile.

That's why I question that you and others spend so much time trying to
educate him by endlessly repeating the same facts and conclusions. I
think the Piper would quit marching if the rats would not follow.
--
Jeff Barnett

On 6/26/2021 11:15 AM, Richard Damon wrote:
> On 6/26/21 12:00 PM, olcott wrote:
>> On 6/26/2021 10:06 AM, Richard Damon wrote:
>>> On 6/26/21 10:55 AM, olcott wrote:
>>>> On 6/26/2021 5:32 AM, Richard Damon wrote:
>>>>> On 6/25/21 11:07 PM, olcott wrote:
>>>>>> On 6/25/2021 9:07 PM, Richard Damon wrote:
>>>>>>> On 6/25/21 9:46 PM, olcott wrote:
>>>>>>>> On 6/25/2021 8:37 PM, Richard Damon wrote:
>>>>>>>>> On 6/25/21 9:01 PM, olcott wrote:
>>>>>>>>>> On 6/25/2021 7:40 PM, Richard Damon wrote:
>>>>>>>>>>> On 6/25/21 6:56 PM, olcott wrote:
>>>>>>>>>>>> On 6/25/2021 4:59 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 6/25/21 4:40 PM, olcott wrote:
>>>>>>>>>>>>>> On 6/25/2021 3:11 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 6/25/21 2:50 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 6/25/2021 12:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> WRONG. P is DEFINED based on H. If you Hypothetically
>>>>>>>>>>>>>>>>> create
>>>>>>>>>>>>>>>>> a P
>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>> doesn't follow that form, then you are hypothetically
>>>>>>>>>>>>>>>>> creating
>>>>>>>>>>>>>>>>> nonsense
>>>>>>>>>>>>>>>>> and can't use it to for anything logical.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Of every possible encoding of simulating partial halt
>>>>>>>>>>>>>>>> decider H
>>>>>>>>>>>>>>>> that can
>>>>>>>>>>>>>>>> possibly exist  H*, if H* never aborts the simulation of its
>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>> results in the infinite execution of the invocation of of
>>>>>>>>>>>>>>>> P(P)
>>>>>>>>>>>>>>>> then a
>>>>>>>>>>>>>>>> simulating halt decider H that does abort its simulation of
>>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>> does correctly decide that this input does specify the never
>>>>>>>>>>>>>>>> halting
>>>>>>>>>>>>>>>> behavior of an infinite chain of invocations.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Yes, if H* is an element of the set of non-aborting deciders
>>>>>>>>>>>>>>> (Hn), P
>>>>>>>>>>>>>>> will result in infinite recursion,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Which logically entails beyond all possible doubt that the
>>>>>>>>>>>>>> set of
>>>>>>>>>>>>>> encodings of simulating partial halt deciders H2* that do
>>>>>>>>>>>>>> abort
>>>>>>>>>>>>>> the
>>>>>>>>>>>>>> simulation of the (P,P) input would correctly report that this
>>>>>>>>>>>>>> input
>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>
>>>>>>>>>>>>> WHY?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Axiom(1) Every computation that never halts unless its
>>>>>>>>>>>> simulation is
>>>>>>>>>>>> aborted is a computation that never halts. This verified as
>>>>>>>>>>>> true on
>>>>>>>>>>>> the
>>>>>>>>>>>> basis of the meaning of its words.
>>>>>>>>>>>
>>>>>>>>>>> WRONG.
>>>>>>>>>>>
>>>>>>>>>>> Your test does not match the plain meaning of the words, as has
>>>>>>>>>>> been
>>>>>>>>>>> explained many times.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Those words may be over your head, yet several others understand
>>>>>>>>>> that
>>>>>>>>>> they are necessarily correct.
>>>>>>>>>
>>>>>>>>> I have seen NO ONE agree to your interpretation of it. The plain
>>>>>>>>> meaning
>>>>>>>>> is that if it can be shown that if the given instance of the
>>>>>>>>> simulator
>>>>>>>>> simulating a given input doesn't stop its simulation that this
>>>>>>>>> simulation will run forevr, then the machine that is being
>>>>>>>>> simulated
>>>>>>>>> can
>>>>>>>>> be corrected decided as non-Halting.
>>>>>>>>>
>>>>>>>>> An more formal way to say that is if UTM(P,I) is non-halting then
>>>>>>>>> it is
>>>>>>>>> correct for H(P,I) to return the non-halting result.
>>>>>>>>>
>>>>>>>>> This actually follows since UTM(P,I) will be non-halting if and
>>>>>>>>> only if
>>>>>>>>> P(I) is non-halting by the definition of a UTM, so that
>>>>>>>>> statement is
>>>>>>>>> trivially proven.
>>>>>>>>>
>>>>>>>>> Your interpretation, where even if a copy of the algorithm of H is
>>>>>>>>> included in P and that included copy needs to abort the
>>>>>>>>> simulation of
>>>>>>>>> the copy of the machine that it was given, can be PROVEN wrong, as
>>>>>>>>> even
>>>>>>>>> you have shown that P(P) in this case does Halt, thus your claimed
>>>>>>>>> correct answer is wrong by the definition of the problem.
>>>>>>>>>
>>>>>>>>> Only if you define that your answer isn't actually supposed to
>>>>>>>>> be the
>>>>>>>>> answer to the halting problem can you justify your answer to be
>>>>>>>>> correct,
>>>>>>>>> but then you proof doesn't achieve the goal you claim.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>> Note, it is easy to show that your interpretation is wrong since
>>>>>>>>>>> even
>>>>>>>>>>> you admit that Linz H^, now called P by you will come to its end
>>>>>>>>>>> and
>>>>>>>>>>> halt when given it own representation as its input, and thus
>>>>>>>>>>> is BY
>>>>>>>>>>> DEFINITION a Halting Computation, Thus the H deciding it didn't
>>>>>>>>>>> need to
>>>>>>>>>>> abort its execution to get the wrong answer of Non-Halting.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Because at least one invocation of the infinite invocation chain
>>>>>>>>>> specified by P(P) had to be terminated to prevent the infinite
>>>>>>>>>> execution
>>>>>>>>>> of this infinite invocation chain it is confirmed beyond all
>>>>>>>>>> possible
>>>>>>>>>> doubt that P(P) specifies an invocation chain.
>>>>>>>>>
>>>>>>>>> WRONG. Given that we have an H that can answer H(P,P) because it
>>>>>>>>> knows
>>>>>>>>> at least enough to terminate the pattern you describe, then when
>>>>>>>>> we run
>>>>>>>>> P(P) then because the H within it also knows to abort this sequence
>>>>>>>>> (since it is built on the same algorithm) this P is NOT part of an
>>>>>>>>> infinite chain of execution, and thus its H can return its (wrong)
>>>>>>>>> answer to it and that P can then Halt.
>>>>>>>>
>>>>>>>> P(P) specifies in infinite invocation sequence that is terminated
>>>>>>>> on its
>>>>>>>> third invocation of H(P,P).
>>>>>>>>
>>>>>>>> P(P) specifies in infinite invocation sequence that is terminated
>>>>>>>> on its
>>>>>>>> third invocation of H(P,P).
>>>>>>>>
>>>>>>>> P(P) specifies in infinite invocation sequence that is terminated
>>>>>>>> on its
>>>>>>>> third invocation of H(P,P).
>>>>>>>>
>>>>>>>> P(P) specifies in infinite invocation sequence that is terminated
>>>>>>>> on its
>>>>>>>> third invocation of H(P,P).
>>>>>>>>
>>>>>>>> P(P) specifies in infinite invocation sequence that is terminated
>>>>>>>> on its
>>>>>>>> third invocation of H(P,P).
>>>>>>>>
>>>>>>>> Now I have told this this several hundred times.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> WRONG.
>>>>>>>
>>>>>>> P(P) starts.
>>>>>>>
>>>>>>> Calls H(P,P)
>>>>>>>
>>>>>>> H starts the simulation.
>>>>>>>
>>>>>>> H simulates P starting
>>>>>>>
>>>>>>> H simulates P calling H
>>>>>>>
>>>>>>> H simulates H starting its simulation
>>>>>>>
>>>>>>> H simulates H simulating P starting
>>>>>>>
>>>>>>> H simulates H simulating P calling H
>>>>>>>
>>>>>>> The first H about here detects what it THINKS is an infinite
>>>>>>> execution
>>>>>>>
>>>>>>> THe first H aborts its simulation
>>>>>>>
>>>>>>> The first H returns its answer (Non-Halting) to its caller
>>>>>>>
>>>>>>> P then Halts
>>>>>>>
>>>>>>> Showing P is a Halting Computation.
>>>>>>
>>>>>> As you already admitted P ONLY halts because some H aborts some P
>>>>>> otherwise P never ever halts.
>>>>>>
>>>>>> As you already admitted P ONLY halts because some H aborts some P
>>>>>> otherwise P never ever halts.
>>>>>>
>>>>>> As you already admitted P ONLY halts because some H aborts some P
>>>>>> otherwise P never ever halts.
>>>>>>
>>>>>> As you already admitted P ONLY halts because some H aborts some P
>>>>>> otherwise P never ever halts.
>>>>>>
>>>>>> As you already admitted P ONLY halts because some H aborts some P
>>>>>> otherwise P never ever halts.
>>>>>>
>>>>>
>>>>> Yes, P halts because the H it contains terminated the simulation of
>>>>> another copy of its description.
>>>>>
>>>>> YOUR problem is that you think that actually means something, it
>>>>> doesn't
>>>>>
>>>>
>>>> Whenever one invocation of the infinite invocation chain of infinite
>>>> recursion is aborted the whole chain terminates.
>>>
>>> WRONG, if the aborting is occurring inside the chain, which it is in
>>> this case.
>>>
>>
>> In the computation int main() { P(P); } If no P ever halts unless some H
>> aborts some P this proves beyond all possible doubt that P(P) specifies
>> an infinitely recursive chain of invocations.
>>
>> That it took me so long to find these words proves that I am a
>> relatively terrible communicator. On the other hand these words do
>> unequivocally validate that my logic was correct all along.
>>
>
> But if your H does answer the question H(P,P) then the P DOES Halt,

strong color theorem: most regular graphs of degree d squared are d + one colorable.

On 6/26/21 12:18 PM, olcott wrote:
> On 6/26/2021 11:08 AM, Richard Damon wrote:
>> On 6/26/21 11:52 AM, olcott wrote:
>>> On 6/26/2021 9:51 AM, Ben Bacarisse wrote:
>>>> I've trimmed the newsgroups.  I suggest everyone else does so as well.
>>>> There is no need to damage more than one group with this junk.
>>>>
>>>> Jeff Barnett <jbb@notatt.com> writes:
>>>>
>>>>> On 6/26/2021 2:11 AM, Chris M. Thomasson wrote:
>>>>>> Are you nuts, or are recovering from a recent head injury?
>>>>>
>>>>> It's not recent. It seems he's been at it for a few decades.
>>>>
>>>> I first cam across PO when he was about to get rich selling some
>>>> software based on two junk patents he'd filed.  The software was vapour
>>>> ware (at the time) but the expectation of riches was real enough.  The
>>>> situation may be reversed now.
>>>>
>>>> I appear to have first talked about halting with PO in 2012.  I had a
>>>> look at one of the replies I made back then.  See how predictable it
>>>> all
>>>> is:
>>>>
>>>>     "You see?  No connection to what I said.  No discussion.  Just a
>>>>     re-statement of the same false claim.  Should I state, yet
>>>> again, why
>>>>     it's false?  Is there any reason to think you'd address the
>>>> argument
>>>>     if I did so?"
>>>>
>>>> That's a shade off 20 years ago.  It really is futile.
>>>>
>>>
>>> On 10/17/2006 7:03 PM, Ben Bacarisse wrote:
>>>> "Peter Olcott" <NoSpam@SeeScreen.com> writes:
>>>
>>> It is the case that P(P) has infinite execution unless one its infinite
>>> chain of invocations is aborted.
>>>
>>> You know there is no rebuttal to this because it is an easily verifiable
>>> fact, even Richard acknowledged that P(P) never halts
>>
>> Right, IF H doesn't abort P then P in non-halting.
>>
>> That does NOT mean that if H does abort a DIFFERENT P (since changing H
>> changes P) that this different P is also non-halting.
>>
>
> In the computation int main() { P(P); } when no P ever halts unless some
> H aborts some P this proves beyond all possible doubt that P(P)
> specifies an infinitely recursive chain of invocations.
>

Then you consider this an infinite loop:

for(int i=0; isLessThan(i, 5); i++) continue;

By the definition, if P halts because of its own algorithm, which
includes the algorithm of the H embedded in it, then it is a Halting
Computation.

> The computation int main() { P(P); } calls H(P,P) which is the first
> invocation of an infinite chain of invocations. Whenever P calls H(P,P)
> H must abort its simulation of P.

RIGHT, H aborts the SIMULATION of P, and returns its answer to its
caller, P which then Halts.

What do you disagree about that?

>
> It is common knowledge that when any invocation of an infinite sequence
> of invocations (such as infinite recursion or infinitely nested
> simulation) is terminated then the entire sequence halts.

WRONG. First, it NEVER was an infinite sequence of invocation, because H
was always going to abort it (or it would NEVER abort it). Thus the rule
really doesn't apply.

Second, if you are in a chain of potentially infinite recursion and a
piece of that chain takes an action to end the potentially infinite
recursion then the chain SUBSEQUENT to the termination is halted, and
the rest can continue. You confuse the case where the decider isn't part
of the loop.

Let me ask you, when the entire sequence is halted, does that mean the
H(P,P) that was the second part of the chain was halted too? Are you
saying it never gives its answer? That means that it does the same when
it is the first piece of the chain!

>
> In the computation int main() { P(P); }  the third element of the
> infinite chain of invocations is terminated. The only reason that any P
> ever halts is that some H aborted some P. This proves (axiomatically)
> that P(P) really does specify an infinite invocation chain.
>
>

Right, the H that is part of P decided to end what would otherwise b4 an
infinite sequence, and thus it kept itself finite. Just like this loop
takes action to keep itself finite:

for(int i=0; i < 5; i++) continue;

If I neer did its test, it would be infinite.

If the H that is part of P didn't do the test it would be infinite.

SAME PATTERN. SAME REASONING.

FAIL.

Your Axiomatically claim is just your code word that you have no idea
how to even attempt to prove it. The word doesn't mean what you think it
does. It shows that you are out of your league of understanding.

On 6/26/21 12:29 PM, olcott wrote:
But if your H does answer the question H(P,P) then the P DOES Halt,
>
> Every competent software engineer knows that an infinitely recursive
> chain of invocations stops as soon as one link in this chain is broken.

WRONG, once the POTENTIALLY infinitely recursive chain of invocations is
broken, then the part that HAS been run can return from the point that
the sequence was broken.

>
> Every competent software engineer knows that when the whole chains stops
> because one link is broken that this provides no evidence that it was
> not an infinitely recursive chain of invocations.

No, ever competent software engineer knows that when a part of the
program takes action to prevent infinite execution, then the execution
continues from the point the the action toke part.

I will agreeeto one point you make, Yes, the detecting of the
potentially infinite loop and breaking it does not itself provide
evidence that program being simulated was not infinitely recursive, but
then neither does it provide evidence that it was.

When we can see that the program actual WAS part of the believed
infinite recursion then the fact that a piece of the loop had the
ability to stop the loop. and that when it returns the loop does not
re-establish itself DOES show that the loop was not truly infinite.

We can not get this from just running H(P,P), but only from running P(P)
as the top machine, the fact that IT will come to a halt is the ultimate
proof that P(P) can't be a non-halting computation.

>
> When people that are not competent software engineers argue against this
> they look very foolish.
>

Yes, you do.

try using "num main()" instead

Jeff Barnett <jbb@notatt.com> writes:

> That's why I question that you and others spend so much time trying to
> educate him by endlessly repeating the same facts and conclusions. I
> think the Piper would quit marching if the rats would not follow.

I don't appreciate the analogy.

--
Ben.

olcott <NoOne@NoWhere.com> writes:

> On 10/17/2006 7:03 PM, Ben Bacarisse wrote:
>> "Peter Olcott" <NoSpam@SeeScreen.com> writes:
>
> It is the case that P(P) has infinite execution...

I did not quote you saying that 2006. That attribution line is a lie.

--
Ben.

On 6/26/21 1:57 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>
>> On 10/17/2006 7:03 PM, Ben Bacarisse wrote:
>>> "Peter Olcott" <NoSpam@SeeScreen.com> writes:
>>
>> It is the case that P(P) has infinite execution...
>
> I did not quote you saying that 2006. That attribution line is a lie.
>

Which makes it not that much different than the rest of what he writes.

monotone reason is linearly decidable.
try using "num main()" instead.

On 6/26/2021 9:23 AM, Jeff Barnett wrote:
> On 6/26/2021 8:51 AM, Ben Bacarisse wrote:
>> I've trimmed the newsgroups.  I suggest everyone else does so as well.
>> There is no need to damage more than one group with this junk.
>>
>> Jeff Barnett <jbb@notatt.com> writes:
>>
>>> On 6/26/2021 2:11 AM, Chris M. Thomasson wrote:
>>>> Are you nuts, or are recovering from a recent head injury?
>>>
>>> It's not recent. It seems he's been at it for a few decades.
>>
>> I first cam across PO when he was about to get rich selling some
>> software based on two junk patents he'd filed.  The software was vapour
>> ware (at the time) but the expectation of riches was real enough.  The
>> situation may be reversed now.
>
> I only know about one junk patent - a character reader.

[...]
> That's why I question that you and others spend so much time trying to
> educate him by endlessly repeating the same facts and conclusions. I
> think the Piper would quit marching if the rats would not follow.

Oh, ouch! ;^/

That's why I question that you and others spend so much time trying to
educate him by endlessly repeating the same facts and conclusions. I
think the Piper would quit marching if the rats would not follow.

Oh, ouch! ;^/

is bitcoin based on halting problem theory?
what should americans do about that?
frankly, i would sell all my bitcoin as
fast as humanly possible to the
chinese and then buy ptoctor and gamble
to support fifty year planning for
the soap on the oceans snows
on the mountain ranges agenda

On 6/25/2021 12:39 AM, wij wrote:
> On Friday, 25 June 2021 at 07:26:09 UTC+8, Chris M. Thomasson wrote:
>> On 6/22/2021 5:45 PM, wij wrote:
>>> On Wednesday, 23 June 2021 at 06:57:58 UTC+8, Richard Damon wrote:
>>>> On 6/22/21 3:22 PM, Chris M. Thomasson wrote:
>>>>> On 6/21/2021 6:54 PM, Richard Damon wrote:
>>>>>>
>>>>>> Well, the problem is that Turing Machines CAN'T be black boxes. And the
>>>>>> definition of the Halting Problem is that the decider is given a full
>>>>>> description of the Turing Machine, which is basically like a full
>>>>>> listing of the program.
>>>>>
>>>>> Oh, sorry. I thought his x86 simulator would run an x86 program and
>>>>> determine if it would halt or not. My bad. The assembled program would
>>>>> have all the information he needs right? Or, would I have to give him
>>>>> source code... Humm, I don't know. Does he have an assembler?
>>>>>
>>>>> When I say "black box", I was basically referring to a program that
>>>>> somebody else assembled into an executable.
>>>>>
>>>>> His simulator, as-is, should be able to simulate any x86 program and
>>>>> determine if it halts or not... Sound Kosher?
>>>>>
>>>>>
>>>> The problem is that the term 'black box' tend to mean something that you
>>>> can't look inside of, which means that his simulator couldn't get at the
>>>> object code of it.
>>>>
>>>> A program that was a real black box would have its internals encrypted
>>>> and have test to make sure that it wasn't being 'spied' on before
>>>> decrypting itself. Of course, without support from the OS, or some
>>>> controlling program, things can't be perfect black boxes, just enough to
>>>> be a pain to look into.
>>>
>>> Black box program can be executed, like any app., by simulator or OS.
>>> The same as oracle can be used in TM, P can be a black box to H, black body
>>> in physics.
>>>
>>
>> A valid x86 program should just run on his simulator. The simulator
>> would start getting instructions and executing them. The question is,
>> will the instruction stream halt, or not? I am guessing that his system
>> would spawn a simulator in a sandbox or something, with a target
>> program. The simulator fires up, initializes itself, and starts
>> executing the target program.
>
> // program p.cpp
> //-------------------
> //extern bool H(Func p);
> void P();
>
> inline static bool H2(Func p) {
> // Rewrite H to simulate H (or not).
> // The rewrite can be in very different but functionally equivalent ways.
> }
>
> static const bool r=H2(P); // equivalent to r=H(P)
>
> void P() {
> if(r) {
> for(;;) {}; // If H2(P)==true, P is in infinite loop.
> }
> };
>
> int main() {
> P();
> };
>
> // Note: P is written this way to demonstrate a way that H cannot possibly detect
> // being traced by P.
> //-----------
>
> If H is a pure simulator, H(P) is doomed to be in infinite recursive call.
> If H(f) is specified to return true iff f() returns, and not allowed to halt,
> then the question is equivalent to asking for the value of r.
>
> If r==true, H spec. says the execution of P() will return, but the compiled
> executable of p.cpp will disagree (run in infinite loop).
> If r==false, H spec. says the execution of P() will not return, but the compiled
> executable of p.cpp will return.
>
> I see no way function H can be done even using quantum computers.
>

PO should run your program on his simulator and give us a result... ;^)

On 6/26/2021 11:55 AM, Ben Bacarisse wrote:
> Jeff Barnett <jbb@notatt.com> writes:
>
>> That's why I question that you and others spend so much time trying to
>> educate him by endlessly repeating the same facts and conclusions. I
>> think the Piper would quit marching if the rats would not follow.
>
> I don't appreciate the analogy.

Sorry but do you have another gentler but more pithy/cheesy substitute?

Also, I'm in there with you all so don't take it as a shot at you.
--
Jeff Barnett

On 6/26/21 12:23 PM, Jeff Barnett wrote:
>
> That's why I question that you and others spend so much time trying to
> educate him by endlessly repeating the same facts and conclusions. I
> think the Piper would quit marching if the rats would not follow.

I don't spend 'that much' time at it, his comments are easy to rebut,
and I just check when I have spare time.

It also is a bit of mental exercise to keep things fit.

Although, I will admit sometimes feel a bit bad about fighting against
an unarmed man in the battle of wits.

He does have doggedly determined down pat though.

On 6/26/2021 12:57 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>
>> On 10/17/2006 7:03 PM, Ben Bacarisse wrote:
>>> "Peter Olcott" <NoSpam@SeeScreen.com> writes:
>>
>> It is the case that P(P) has infinite execution...
>
> I did not quote you saying that 2006. That attribution line is a lie.
>

I am just pointing out the date and time that you first spoke to me
knucklehead. It was not 2012. Then I go on to point out the irrefutable
reasoning that proves that I am correct.

It is the case that P(P) has infinite execution unless one of its
infinite chain of invocations is aborted.

You know there is no rebuttal to this because it is an easily verifiable
fact, even Richard acknowledged that P(P) never halts:

On 6/25/2021 3:11 PM, Richard Damon wrote:
>
> Yes, if H* is an element of the set of non-aborting deciders (Hn), P
> will result in infinite recursion,

So you will misdirect with ad hominem and rhetoric because you know that
there is no plausible rebuttal using logic.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 6/26/2021 6:20 PM, Richard Damon wrote:
> On 6/26/21 12:23 PM, Jeff Barnett wrote:
>>
>> That's why I question that you and others spend so much time trying to
>> educate him by endlessly repeating the same facts and conclusions. I
>> think the Piper would quit marching if the rats would not follow.
>
> I don't spend 'that much' time at it, his comments are easy to rebut,
> and I just check when I have spare time.
>
> It also is a bit of mental exercise to keep things fit.
>
> Although, I will admit sometimes feel a bit bad about fighting against
> an unarmed man in the battle of wits.
>
> He does have doggedly determined down pat though.
>

A not quite genius can out perform profoundly brilliant geniuses on a
specific task such as the halting problem when 10,000-fold more time and
effort is applied. By going over all the details enormously more times
than anyone else has patience for, details that were never noticed
before are uncovered.

Genius is one per cent inspiration and ninety-nine per cent
perspiration. Thomas Edison.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 6/26/21 8:01 PM, olcott wrote:
> On 6/26/2021 12:57 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>
>>> On 10/17/2006 7:03 PM, Ben Bacarisse wrote:
>>>> "Peter Olcott" <NoSpam@SeeScreen.com> writes:
>>>
>>> It is the case that P(P) has infinite execution...
>>
>> I did not quote you saying that 2006.  That attribution line is a lie.
>>
>
> I am just pointing out the date and time that you first spoke to me
> knucklehead. It was not 2012. Then I go on to point out the irrefutable
> reasoning that proves that I am correct.
>
> It is the case that P(P) has infinite execution unless one of its
> infinite chain of invocations is aborted.

Yes, If H will never abort its P, then THAT P will be non-halting.

Problem is that When you make an H that will abort the simulation, that
gives you a different P which your 'proof' doesn't apply to.

>
> You know there is no rebuttal to this because it is an easily verifiable
> fact, even Richard acknowledged that P(P) never halts:
>
> On 6/25/2021 3:11 PM, Richard Damon wrote:
>>
>> Yes, if H* is an element of the set of non-aborting deciders (Hn), P
>> will result in infinite recursion,

Right If H is a member of Hn which don't abort Pn, then Pn(Pn) will be
non-halting. But Hn will never be able to answer the question Hn(Pn,Pn)
as it gets stuck in that same infinite loop, so doesn't need to be shown
incorrect by P.

If H is a member of Ha that does abort, then Ha can correctly decide
this of Pn. The problem is that It needs to decide Pa, and the proof
doesn't apply to that, so it gets it wrong.

You regularly make this mistake. You forget that the algorithm for the
machine P is a function of the algorithm for the machine H, so you can't
use one H to prove attributes about a different H's P.

>
> So you will misdirect with ad hominem and rhetoric because you know that
> there is no plausible rebuttal using logic.
>
>

So you admit that this is as factual as most of what you say. This
basically says that you are an impeached witness, and EVERYTHING that
you want to 'claim' you really need to provide some sort of 'Proof' or
we don't need to believe it.

olcott <NoOne@NoWhere.com> writes:

> On 6/26/2021 12:57 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 10/17/2006 7:03 PM, Ben Bacarisse wrote:
>>>> "Peter Olcott" <NoSpam@SeeScreen.com> writes:
>>>
>>> It is the case that P(P) has infinite execution...
>> I did not quote you saying that 2006. That attribution line is a lie.
>>
>
> I am just pointing out the date and time that you first spoke to me
> knucklehead. It was not 2012.

I know. I was point out that your attribution line was a lie. You
probably have no idea what that means having only used Usenet for a few
decades.

--
Ben.

-I am just pointing out the date and time that you first spoke to me
-knucklehead. It was not 2012. Then I go on to point out the irrefutable
how can someone care so much about others opinions? have you studied
your reasons for collecting "databases of conversations"?

-reasoning I am correct.
- -A not genius can out perform profoundly brilliant geniuses on a
-specific task such as the halting problem when 10,000-fold more time and
-effort is applied. By going over all the details enormously more times
-than anyone else has patience for, details that were never noticed
-before are uncovered.
my bob program for solving polynomial space time problems has a mind
that is one million times my own mind's speed. and yet, i am
much smarter than bob is about halt deciding bob. i would say
that my history of halt deciding a polynomial space time
solver is nearly perfect. would you like a copy of bob
to see how well you do?

+Genius is one per cent inspiration and ninety-nine per cent
+perspiration. Thomas Edison.
pete rose of the cincinnati reds said something similar when i was a boy.