On 6/26/21 8:12 PM, olcott wrote:
> 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.

Firing blanks again.

You have proved NOTHING.

You keep on tring to prove the behavior by looking at the wrong
machines, and ignoring the machine that you need to.

I have yet to see even a shread of a proof out of you, all your
'arguments' begin by claiming as an 'axiom' something that isn't true
with the meaning you want to put into it. These 'Axiom' are often things
that can actually be proved as Theorems with the right meaning of the
words, and provably false for your meaning.

You make claims of these details, but you have admitted that you don't
even understand the basics of the field, so you mind seems to be full of
false conceptions.

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

Yes, but useful perspiration requires that you are able to do REAL work,
so you need to know something about what you are working on.

From what I see, first year students know more about the subject than
you do. You show ZERO understanding of what a Turing Machine actually
is, you can parrot words about it, but show no understanding about what
it actually means. You also don't seem to understand what a computation
is, (and what it isn't).

I have read your work, and you may think it is great stuff, but it is
rot. My best suggestion is you just need to submit the paper to whatever
journal you have your heart set on and get the laughing rejection letter
back.

The one Journal I can think of that might take you paper would be AIR,
but I don't think even they would see a use in your paper, as it isn't
quite believable enough.

On 6/26/2021 7:42 PM, Ben Bacarisse wrote:
> 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 Bacarisse the king of dishonest dodges.
Ben Bacarisse the king of dishonest dodges.
Ben Bacarisse the king of dishonest dodges.

I am daring you (or anyone else) to point out any error in the following.
I am daring you (or anyone else) to point out any error in the following.
I am daring you (or anyone else) to point out any error in the following.

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 7:32 PM, Richard Damon wrote:
> 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 you do not understand that when one invocation of the connected
chain of invocations of infinite recursion int main(){ P(P); }

is aborted thus forcing the whole chain to halt, this does not mean that
int main(){ P(P); } does not specify a chain of infinite invocations.

Everyone here that is proficient at software engineering knows that I am
correct about this.

--
Copyright 2021 Pete Olcott

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

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

+Ben Bacarisse the king
+Ben Bacarisse the king
+Ben Bacarisse the king
-I am daring you (or anyone else) to point out any error in the following.
-I am daring you (or anyone else) to point out any error in the following.
-I am daring you (or anyone else) to point out any error in the following.
-That you do not understand that when one invocation of the connected
-chain of invocations of infinite recursion int main(){ P(P); }
- -is aborted thus forcing the whole chain to halt, this does not mean that
-int main(){ P(P); } does not specify a chain of infinite invocations.

try num main() and data type num

-Everyone here that is proficient at software engineering knows that I am
-incorrect about this.

On 6/26/2021 7:48 PM, Daniel Pehoushek wrote:
> -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?

I must first make my point understood by continual improvement of the
words of this point. I can only do this through trial-and-error with
feedback.

Six months ago I had no way to clearly explain exactly why H(P,P)==0 is
correct even though P(P) halts. I now have an irrefutable way to clearly
explain this.

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

Try reading the whole paper, if you are the author that you claim to be
you should have the capacity to understand that it is correct, even
though the form of this paper is not nearly in the ballpark of academic
journal quality. Far too many people rank style over substance.

Halting problem undecidability and infinitely nested simulation

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

--
Copyright 2021 Pete Olcott

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

On 6/26/2021 7:48 PM, Richard Damon wrote:
> On 6/26/21 8:12 PM, olcott wrote:
>> 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.
>
> Firing blanks again.
>
> You have proved NOTHING.
Pearls before swine.

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

This proves beyond all doubt that P(P) specifies a computation that does
not halt.

Halting problem undecidability and infinitely nested simulation

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

--
Copyright 2021 Pete Olcott

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

On 6/26/21 8:54 PM, olcott wrote:
> On 6/26/2021 7:32 PM, Richard Damon wrote:
>> 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 you do not understand that when one invocation of the connected
> chain of invocations of infinite recursion int main(){ P(P); }
>
> is aborted thus forcing the whole chain to halt, this does not mean that
> int main(){ P(P); } does not specify a chain of infinite invocations.
>
> Everyone here that is proficient at software engineering knows that I am
> correct about this.
>

You say this, but refuse to answer the question of when this happens,
what happens to the execution path of the halt decider that made this
decision?

Remember, in this case, you have dectect the loop that includes BOTH P
and H in the loop. Thus this H is PART of the infinite chain that you
claim as ALL gone.

Did you machine just blow up?

Did it just abort the whole program?

Answer this for me, what actually happens.

And then, what does this mean as the behavior of the actual Turing
Machine this is supposed to be the equivalent of?

I don't think you have an answer for this, as once you define what
happens here, we can show how that answer shows you machine was wrong.

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?

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

On 6/26/21 8:49 PM, olcott wrote:
> On 6/26/2021 7:42 PM, Ben Bacarisse wrote:
>> 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 Bacarisse the king of dishonest dodges.
> Ben Bacarisse the king of dishonest dodges.
> Ben Bacarisse the king of dishonest dodges.

Olcott is the emperor of the dishonest dodge, never answering the tough
questions put to him to acutally explain what he is saying,

>
> I am daring you (or anyone else) to point out any error in the following.
> I am daring you (or anyone else) to point out any error in the following.
> I am daring you (or anyone else) to point out any error in the following.
>
> 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.
>

The error is a confusion of same named machines.

It is True that Pn(Pn) based on a decider Hn that doesn't abort its
simulation of Pn will have infinite execution.

It it Ture that Ha, a decider based on an algorithm that will abort the
simulation of this pattern can correct decide Pn(Pn)

The error is that Ha needs to corretly answer for Ha(Pa,Pa), the Pa
based on Ha. It is shown that Ha(Pa,Pa) says non-Halting, but the actual
run of Pa(Pa) shows that it is Halting, the Ha is WRONG.

You LIE like you always do by overloading symbols with different
meanings and moving 'proofs' to things they do not apply to.

WHAT IS YOU ANSWR TO THIS VALID REBUTTAL.
(My guess is you are going to do you normal and just ignore it and lie
again that no one has pointed out an error without you actually pointing
out a factual error in the error being pointed out).

On 6/26/21 9:08 PM, olcott wrote:
> On 6/26/2021 7:48 PM, Richard Damon wrote:
>> On 6/26/21 8:12 PM, olcott wrote:
>>> 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.
>>
>> Firing blanks again.
>>
>> You have proved NOTHING.
> Pearls before swine.
>
> It is the case that P(P) has infinite execution unless one of its
> infinite chain of invocations is aborted.
>
> This proves beyond all doubt that P(P) specifies a computation that does
> not halt.
>
> Halting problem undecidability and infinitely nested simulation
>
> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>

Yep, you are the swine ignoring the pearls.

You have shown that Ha can correctly decider Pn but not Pa thus you
haven't actually made the needed proof.

Detailed in other post just made.

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

On 6/26/2021 8:08 PM, Richard Damon wrote:
> On 6/26/21 8:54 PM, olcott wrote:
>> On 6/26/2021 7:32 PM, Richard Damon wrote:
>>> 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 you do not understand that when one invocation of the connected
>> chain of invocations of infinite recursion int main(){ P(P); }
>>
>> is aborted thus forcing the whole chain to halt, this does not mean that
>> int main(){ P(P); } does not specify a chain of infinite invocations.
>>
>> Everyone here that is proficient at software engineering knows that I am
>> correct about this.
>>
>
> You say this, but refuse to answer the question of when this happens,
> what happens to the execution path of the halt decider that made this
> decision?
>

As long as we can know that P(P) specifies infinite recursion then we
know that H(P,P) did correctly abort its input an report that its input
never halts.

> Remember, in this case, you have dectect the loop that includes BOTH P
> and H in the loop. Thus this H is PART of the infinite chain that you
> claim as ALL gone.
>
> Did you machine just blow up?
>
> Did it just abort the whole program?
>
> Answer this for me, what actually happens.
>

As long as we can know that P(P) specifies infinite recursion then we
know that H(P,P) did correctly abort its input an report that its input
never halts.

This is correct and true no matter what else.

> And then, what does this mean as the behavior of the actual Turing
> Machine this is supposed to be the equivalent of?
> > I don't think you have an answer for this, as once you define what
> happens here, we can show how that answer shows you machine was wrong.
>

As long as we can know that P(P) specifies infinite recursion then we
know that H(P,P) did correctly abort its input an report that its input
never halts.

This is correct and true no matter what else.

If X > Y && Y > Z then X > Z

We don't even need to know what X, Y, and Z are
and we don't need to know the criterion measure of >.

--
Copyright 2021 Pete Olcott

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

On 6/26/2021 8:17 PM, Richard Damon wrote:
> On 6/26/21 8:49 PM, olcott wrote:
>> On 6/26/2021 7:42 PM, Ben Bacarisse wrote:
>>> 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 Bacarisse the king of dishonest dodges.
>> Ben Bacarisse the king of dishonest dodges.
>> Ben Bacarisse the king of dishonest dodges.
>
>
> Olcott is the emperor of the dishonest dodge, never answering the tough
> questions put to him to acutally explain what he is saying,
>
>>
>> I am daring you (or anyone else) to point out any error in the following.
>> I am daring you (or anyone else) to point out any error in the following.
>> I am daring you (or anyone else) to point out any error in the following.
>>
>> 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.
>>
>
> The error is a confusion of same named machines.
>

int Factorial(int n)
{ if (n > 1)
return n * Factorial(n - 1);
else
return 1;
}

That is not the way that recursion works.

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

When P called with the machine address of P invokes simulating halt
decider H(P,P) P is invoking its own machine address in the same way
that Factorial is invoking its own machine address.

--
Copyright 2021 Pete Olcott

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

On 6/26/21 9:39 PM, olcott wrote:
> On 6/26/2021 8:08 PM, Richard Damon wrote:
>> On 6/26/21 8:54 PM, olcott wrote:
>>> On 6/26/2021 7:32 PM, Richard Damon wrote:
>>>> 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 you do not understand that when one invocation of the connected
>>> chain of invocations of infinite recursion int main(){ P(P); }
>>>
>>> is aborted thus forcing the whole chain to halt, this does not mean that
>>> int main(){ P(P); } does not specify a chain of infinite invocations.
>>>
>>> Everyone here that is proficient at software engineering knows that I am
>>> correct about this.
>>>
>>
>> You say this, but refuse to answer the question of when this happens,
>> what happens to the execution path of the halt decider that made this
>> decision?
>>
>
> As long as we can know that P(P) specifies infinite recursion then we
> know that H(P,P) did correctly abort its input an report that its input
> never halts.

Problem is that you keep refering to the wrong P. The P you proved this
for was based on the H that didn't abort. So you need to find an H that
doesn't abort its simulation of P(P) that can still give an answer.

That doesn't exist.

You are talking about Unicorns again.

Yes, AS LONG AS you know that, but that is only for Pn based on Hn.

All you have shown is that Ha can predict Pn but that doesn't matter, it
needs to predict Pa.

>
>> Remember, in this case, you have dectect the loop that includes BOTH P
>> and H in the loop. Thus this H is PART of the infinite chain that you
>> claim as ALL gone.
>>
>> Did you machine just blow up?
>>
>> Did it just abort the whole program?
>>
>> Answer this for me, what actually happens.
>>
>
> As long as we can know that P(P) specifies infinite recursion then we
> know that H(P,P) did correctly abort its input an report that its input
> never halts.
>
> This is correct and true no matter what else.

Except that if H can abort its input of P, then we haven't shown that
P(P) is an infinite recursion.

That proof was based on the presumption that H doesn't abort its input.

Assuption doesn't hold, argument is now unsound. PERIOD.

>
>> And then, what does this mean as the behavior of the actual Turing
>> Machine this is supposed to be the equivalent of?
>>  > I don't think you have an answer for this, as once you define what
>> happens here, we can show how that answer shows you machine was wrong.
>>
>
> As long as we can know that P(P) specifies infinite recursion then we
> know that H(P,P) did correctly abort its input an report that its input
> never halts.

Except, as has been said many times, you have only shown that Pn(Pn)
specifies infinite recursion, and Hn gets caught in that same infinite
recursion. Once you change to Ha that knows how to get out of that trap,
it now needs to decide on Pa, which you have NOT proven infinite
recursion, and in fact it can be shown that it DOESN'T have infinite
recursion BECAUSE H will abort its simulation.
>
> This is correct and true no matter what else.
>
> If X > Y && Y > Z then X > Z

Maybe if you wrote out the logic for the actual case you were arguing it
might be more convising.

Your logic goes more like:

If H doesn't abort its simulation then P(P) has infinite recursion.

H does abort its simulation .... not much you can say now.

>
> We don't even need to know what X, Y, and Z are
> and we don't need to know the criterion measure of >.
>

STRAWMAN, we aren't doing that logic.

On 6/26/21 9:55 PM, olcott wrote:
> On 6/26/2021 8:17 PM, Richard Damon wrote:
>> On 6/26/21 8:49 PM, olcott wrote:
>>> On 6/26/2021 7:42 PM, Ben Bacarisse wrote:
>>>> 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 Bacarisse the king of dishonest dodges.
>>> Ben Bacarisse the king of dishonest dodges.
>>> Ben Bacarisse the king of dishonest dodges.
>>
>>
>> Olcott is the emperor of the dishonest dodge, never answering the tough
>> questions put to him to acutally explain what he is saying,
>>
>>>
>>> I am daring you (or anyone else) to point out any error in the
>>> following.
>>> I am daring you (or anyone else) to point out any error in the
>>> following.
>>> I am daring you (or anyone else) to point out any error in the
>>> following.
>>>
>>> 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.
>>>
>>
>> The error is a confusion of same named machines.
>>
>
> int Factorial(int n)
> {
>   if (n > 1)
>     return n * Factorial(n - 1);
>   else
>     return 1;
> }
>
> That is not the way that recursion works.
>
> void P(u32 x)
> {
>   u32 Input_Halts = H(x, x);
>   if (Input_Halts)
>     HERE: goto HERE;
> }
>
> When P called with the machine address of P invokes simulating halt
> decider H(P,P) P is invoking its own machine address in the same way
> that Factorial is invoking its own machine address.
>

WHO IS THROWING IN A DISHONEST DODGE NOW???????

What does that factorial have to do with the problem at hand at all.

You CLEARLY have no concept of what a Turing Machine is or what a
computation is.

The Turing Machine equivalent of P is NOT just to code you have write as
the function P, but it includes its copy of H and everything that H
uses. THAT IS ALL PART OF P.

Change H, and you change the Machine P. PERIOD.

GO ahead, submit your paper and get laughed at for being a moron.

If you made this sort of argument in a freshman course, the instructor
would likely suggest you look at a different major, it is so bad.

DEFINITION: A Turing machine is a mathematical model of computing that
combines a finite state machine which defines that algorithm of the
computation combined with an infinite tape with a finite symbol set, the
symbol under the current tape head, and the current state being the
inputs to the finite state machine, and the outputs being the next state
for the machine, what symbol to write on the tape in the current
location and if the tape is to move a step forward or backwards for the
next state.

That Finite State Machine contains that COMPLETE algorithm of the
machine, so the machine include ALL the code that is part of it. Thus
machine P includes its copy of the algorithm of machine H.

Change H, and you need to change P.

+++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?++++++
==========================
++++++++++++============
+++++++++=============
====================
=================
==============
===========
go pete o go
pete o go
pete o
go go
go

On 6/26/2021 5:49 PM, olcott wrote:
> On 6/26/2021 7:42 PM, Ben Bacarisse wrote:
>> 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 Bacarisse the king of dishonest dodges.
> Ben Bacarisse the king of dishonest dodges.
> Ben Bacarisse the king of dishonest dodges.
>
> I am daring you (or anyone else) to point out any error in the following.
> I am daring you (or anyone else) to point out any error in the following.
> I am daring you (or anyone else) to point out any error in the following.
[...]

Oh my! Wow, you really are nuts!? I am not a frequent commentator on
your numerous nonsense threads, but wow. There are a lot of people that
are trying their best to help you, big time! Why do you mock and insult
them...? Wow!

;^/

On 6/26/2021 7:33 PM, Daniel Pehoushek wrote:
> +++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?++++++
> ==========================
> ++++++++++++============
> +++++++++=============
> ====================
> =================
> ==============
> ===========
> go pete o go
> pete o go
> pete o
> go go
> go
>

http://fractallife247.com/test/hmac_cipher/ver_0_0_0_1?ct_hmac_cipher=d1b79cd944162e0064a8bceecdfa2d74a7b1de0e8064b403dacc1a7934de866ca2d4b425a4349f8483a21a1bcab32500eea33f4aa2e443af64264b0e8d8edee51d4301a653bb6077e9e009089ce0111dd0375a6556b0912ed2f2667daa757c35a48e654644

On 6/26/2021 9:06 PM, Richard Damon wrote:
> On 6/26/21 9:39 PM, olcott wrote:
>> On 6/26/2021 8:08 PM, Richard Damon wrote:
>>> On 6/26/21 8:54 PM, olcott wrote:
>>>> On 6/26/2021 7:32 PM, Richard Damon wrote:
>>>>> 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 you do not understand that when one invocation of the connected
>>>> chain of invocations of infinite recursion int main(){ P(P); }
>>>>
>>>> is aborted thus forcing the whole chain to halt, this does not mean that
>>>> int main(){ P(P); } does not specify a chain of infinite invocations.
>>>>
>>>> Everyone here that is proficient at software engineering knows that I am
>>>> correct about this.
>>>>
>>>
>>> You say this, but refuse to answer the question of when this happens,
>>> what happens to the execution path of the halt decider that made this
>>> decision?
>>>
>>
>> As long as we can know that P(P) specifies infinite recursion then we
>> know that H(P,P) did correctly abort its input an report that its input
>> never halts.
>
>
> Problem is that you keep refering to the wrong P.
The problem is that people that are dumber than a box of rocks do not
understand that with infinite recursion "any P will do".

An invocation chain remains infinitely recursive until one of its
invocations from the 1 ... n is terminated.

--
Copyright 2021 Pete Olcott

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

On 6/27/21 10:43 AM, olcott wrote:
> On 6/26/2021 9:06 PM, Richard Damon wrote:

>>
>> Problem is that you keep refering to the wrong P.
> The problem is that people that are dumber than a box of rocks do not
> understand that with infinite recursion "any P will do".
>
> An invocation chain remains infinitely recursive until one of its
> invocations from the 1 ... n is terminated.
>

Then explain in simple words how you can examine program A to determine
the Halting behavior of program B.

Note, although you call then all 'P', they are TOTALLY different
programs, with just the smallest part of common code.

This is what you forget.

Remember, you are using the Halting Problem defined for Turing Machines,
so you need to work under the rules of Turing Machines, and that means
that machine P includes ALL the code that is part of its algorithm,
which includes the H that it is built on.

IF you want to claim that you can determine detail characteristics of a
Cat by examining a Dog, please give your justification.

If we start with an H that does include the code to abort what it sees
as an infinite recursion, then it is clear that the P built from this
algorithm also does not get stuck in an infinite recursion, as it starts
to simulate itself, then sees that same pattern that H would (since it
is the same algorithm as H) and decide to abort its simulation, and then
Halt.

A Computation that Halt, is a Halting Computation, and not one that has
gotten stuck in an infinite recursion.

Your UNSOUND deduction that you can analyze this version of P by
treating it just the same as to version built on an algorithm that
doesn't terminate the simulation is totally flawed, which is why you get
the wrong answer.

On Sunday, 27 June 2021 at 00:04:35 UTC+1, Jeff Barnett wrote:
> On 6/26/2021 11:55 AM, Ben Bacarisse wrote:
> > Jeff Barnett <j...@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.
>
Seagulls following the sprats of easy points that the trolling trawler leaves
in its wake.

On 6/27/2021 12:10 PM, Richard Damon wrote:
> On 6/27/21 10:43 AM, olcott wrote:
>> On 6/26/2021 9:06 PM, Richard Damon wrote:
>
>>>
>>> Problem is that you keep refering to the wrong P.
>> The problem is that people that are dumber than a box of rocks do not
>> understand that with infinite recursion "any P will do".
>>
>> An invocation chain remains infinitely recursive until one of its
>> invocations from the 1 ... n is terminated.
>>
>
> Then explain in simple words how you can examine program A to determine
> the Halting behavior of program B.
>
> Note, although you call then all 'P', they are TOTALLY different
> programs, with just the smallest part of common code.
>

That the different levels of infinite recursion are different programs
is such a foolishly stupid thing to say.

int Factorial(int n)
{ if (n > 1)
return n * Factorial(n - 1);
else
return 1;
}

> This is what you forget.
>
> Remember, you are using the Halting Problem defined for Turing Machines,
> so you need to work under the rules of Turing Machines, and that means
> that machine P includes ALL the code that is part of its algorithm,
> which includes the H that it is built on.

I am only talking about the C/x86 version of H/P nitwit.

--
Copyright 2021 Pete Olcott

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

On 27/06/2021 18:54, Malcolm McLean wrote:
> On Sunday, 27 June 2021 at 00:04:35 UTC+1, Jeff Barnett wrote:
>> On 6/26/2021 11:55 AM, Ben Bacarisse wrote:
>>> Jeff Barnett <j...@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.
>>
> Seagulls following the sprats of easy points that the trolling trawler leaves
> in its wake.
>

You're suggesting that the trawlers would quit trawling if the seagulls
didn't follow in their wake? :)

So the whole seagull/trawler analogy doesn't quite work, although I'll
grant seagulls can be nicer than rats, provided we exclude the naughty
ones that swipe your bag of chips or jump up and down on your caravan
roof at the break of dawn...

Mike.

On 6/27/21 2:00 PM, olcott wrote:
> On 6/27/2021 12:10 PM, Richard Damon wrote:
>> On 6/27/21 10:43 AM, olcott wrote:
>>> On 6/26/2021 9:06 PM, Richard Damon wrote:
>>
>>>>
>>>> Problem is that you keep refering to the wrong P.
>>> The problem is that people that are dumber than a box of rocks do not
>>> understand that with infinite recursion "any P will do".
>>>
>>> An invocation chain remains infinitely recursive until one of its
>>> invocations from the 1 ... n is terminated.
>>>
>>
>> Then explain in simple words how you can examine program A to determine
>> the Halting behavior of program B.
>>
>> Note, although you call then all 'P', they are TOTALLY different
>> programs, with just the smallest part of common code.
>>
>
> That the different levels of infinite recursion are different programs
> is such a foolishly stupid thing to say.

Nonsense.

There are MANY programs that you call 'P', just as you talk about many
different H's

A key fact that you omit is that each H that you consider gets its own P
that it needs to decide, and those Ps are as different as the Hs they
are based on.

You REALLY need to keep the different machines straight, best done by
giving them unique names. It almost seems like you have forgotten the
distinction between the concept of the Formal Parameter used to define a
function and the actual argument given in the particular instance. The
machine in Linz is called H^ for a reason, it is the ^ transform for
machine H. Thus if the ACTUAL halt decider that claims to be able to
decide all machines given to it is called Halts, then the Machine that
Linz would propose would be called Halts^. Thus for things like your
halt decider that doesn't abort its input could be called Hn and thus
Linz would make a Hn^, and the Halt decider that does abort its input
when it detects your given pattern could be called Ha, and its Linz
challenger would be Ha^. Now things are well labled, and you argument is
that because we can easily look at the results of running Hn^ and seeing
infinite recursion, we can run Ha(Hn^,Hn^) and properly say that the
answer of non-Halting is correct, which IS a valid statement.

The problem is that Ha needs to get Ha^(Ha^) correct, which it doesn't
because the logic used to show Hn^(Hn^) was infinitly recursive doesn't
apply as Ha DOES terminate the loop, and thus so does Ha^ since it
copies the algorithm.

>
> int Factorial(int n)
> {
>   if (n > 1)
>     return n * Factorial(n - 1);
>   else
>     return 1;
> }
>

STRAWMAN.

>> This is what you forget.
>>
>> Remember, you are using the Halting Problem defined for Turing Machines,
>> so you need to work under the rules of Turing Machines, and that means
>> that machine P includes ALL the code that is part of its algorithm,
>> which includes the H that it is built on.
>
> I am only talking about the C/x86 version of H/P nitwit.
>
>

Then why are you using a Turing Machine reference design?

You have previously claimed that you are refuting Linz and the like,
which are ALL Turing Macnines based proofs.

In your earlier arguemnts you claimed that your machine H/Halts was an
equivalent to the Turing Machine H in the proof.

Are you retracting that claim? If you are claiming equivalence, then the
properties of Turing Machines still apply.

Note, this equivalent principle means that the machine that P represents
includes ALL of the code of H as part of it (even if it isn't part of
what you call P in C), thus changing H changes P.

Big Note about a C/x86 version of the Halting Problem. You need to be
VERY careful how you define things. First, because an x86 program that
doesn't do I/O is a finite program, it turns out that this means that if
you allow the Halt Decider to be an enough bigger machine, ANY such
finite machine can be correctly decided in finite time. (This setup also
means we can't form H^, as H^ needs to be the x86 program but H doesn't,
it can be bigger).

If we limit the Halt Decider to need to fit into the same finite
machine, it is easy to show that there are MANY programs that can't be
decided, all you need is for it to take up enough space that there is no
room left for the decider to fit with it.

IF we add I/O with bounded I/O space, we hit the same issue. Solvable it
the decider can be bigger (if you allow it to be enough bigger) and
unsolvable if your total memory has a fixed limit.

This means the only x86 style of Computations that gets interesting for
a general halting decider is one that allows for unbounded I/O. From
your description, your decider doesn't seem to have defined an API to do
this, and doesn't even allow you to run a decision on an arbitrary
computation due to your memory system. A REAL x86 theory of computation
decider would have a call where you provide the computation to decide as
a FILE (not a pointer to memory) so you really could provide an
arbitrary program to decide on.

A real theory of decider wouldn't have (or need) an 'out' for running
out of memory. Any decider that has a fixed memory bound is going to
have machines that it can not decide on, even if they are restricted to
that same memory bound.