Since Turing machines are mathematical objects that only exist in the
mind people can have contradictory thus incoherent ideas about these
abstract mathematical objects and never realize that their ideas are
incoherent.

When we study the theory of computation using physically existing
machines such as the x86 architecture then the incoherent abstract ideas
are shown to be incoherent in that they cannot be physically implemented.

void Px(ptr x)
{ H(x, x);
return;
}

int main()
{ Output("Input_Halts = ", H(Px, Px));
}

If a decider must always return a value whenever it is called this
requires H to return a value to Px even though H is called in infinite
recursion.

This even requires that the function call from Px to H(Px,Px) must
return a value to Px even if this function call to H is not even
executed. In the physical model of computation it is an axiom the
programs that are not executed never return values because it is
physically impossible.

When simulating halt decider H sees that Px is about to call H(Px,Px) in
infinite recursion H aborts its simulation of Px before this call is
executed.

*Clearly computer science is incorrect on this point*
Computer science says that H must still return a value to Px even though
the call to H is not even executed because all deciders must ALWAYS
return to their caller.

--
Copyright 2022 Pete Olcott

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

On Sun, 28 Aug 2022 14:47:08 -0500
olcott <NoOne@NoWhere.com> wrote:

> Since Turing machines are mathematical objects that only exist in the
> mind people can have contradictory thus incoherent ideas about these
> abstract mathematical objects and never realize that their ideas are
> incoherent.
>
> When we study the theory of computation using physically existing
> machines such as the x86 architecture then the incoherent abstract
> ideas are shown to be incoherent in that they cannot be physically
> implemented.
>
> void Px(ptr x)
> {
> H(x, x);
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H(Px, Px));
> }
>
> If a decider must always return a value whenever it is called this
> requires H to return a value to Px even though H is called in
> infinite recursion.
>
> This even requires that the function call from Px to H(Px,Px) must
> return a value to Px even if this function call to H is not even
> executed. In the physical model of computation it is an axiom the
> programs that are not executed never return values because it is
> physically impossible.
>
> When simulating halt decider H sees that Px is about to call H(Px,Px)
> in infinite recursion H aborts its simulation of Px before this call
> is executed.
>
> *Clearly computer science is incorrect on this point*
> Computer science says that H must still return a value to Px even
> though the call to H is not even executed because all deciders must
> ALWAYS return to their caller.

Computer science is correct on this point, what is incorrect is your
implementation of H.

/Flibble

On Sunday, 28 August 2022 at 21:47:18 UTC+2, olcott wrote:
> Since Turing machines are mathematical objects that only exist in the
> mind people can have contradictory thus incoherent ideas about these
> abstract mathematical objects and never realize that their ideas are
> incoherent.
>
> When we study the theory of computation using physically existing
> machines such as the x86 architecture then the incoherent abstract ideas
> are shown to be incoherent in that they cannot be physically implemented.
>
> void Px(ptr x)
> {
> H(x, x);
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H(Px, Px));
> }
>
> If a decider must always return a value whenever it is called this
> requires H to return a value to Px even though H is called in infinite
> recursion.
>
> This even requires that the function call from Px to H(Px,Px) must
> return a value to Px even if this function call to H is not even
> executed. In the physical model of computation it is an axiom the
> programs that are not executed never return values because it is
> physically impossible.
>
> When simulating halt decider H sees that Px is about to call H(Px,Px) in
> infinite recursion H aborts its simulation of Px before this call is
> executed.
>
> *Clearly computer science is incorrect on this point*
> Computer science says that H must still return a value to Px even though
> the call to H is not even executed because all deciders must ALWAYS
> return to their caller.
Olcott, you moron.

Read the paper on Infinite Time Turing Machines already.

Every single computer scientist and Mathematician in 2022 is actually USING that model of computation in their head. They speak of transfinite ordinals, they speak of N, R and C. They speak of infinities as if they are no big deal.
They are pretending that infinite operations halt, they are performing infinite sums.

It's obvious to ANY non-idiot that they are obviously NOT using Turing machines, because Turing Machines are bounded to finite time!

On 8/28/2022 3:02 PM, Mr Flibble wrote:
> On Sun, 28 Aug 2022 14:47:08 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> Since Turing machines are mathematical objects that only exist in the
>> mind people can have contradictory thus incoherent ideas about these
>> abstract mathematical objects and never realize that their ideas are
>> incoherent.
>>
>> When we study the theory of computation using physically existing
>> machines such as the x86 architecture then the incoherent abstract
>> ideas are shown to be incoherent in that they cannot be physically
>> implemented.
>>
>> void Px(ptr x)
>> {
>> H(x, x);
>> return;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H(Px, Px));
>> }
>>
>> If a decider must always return a value whenever it is called this
>> requires H to return a value to Px even though H is called in
>> infinite recursion.
>>
>> This even requires that the function call from Px to H(Px,Px) must
>> return a value to Px even if this function call to H is not even
>> executed. In the physical model of computation it is an axiom the
>> programs that are not executed never return values because it is
>> physically impossible.
>>
>> When simulating halt decider H sees that Px is about to call H(Px,Px)
>> in infinite recursion H aborts its simulation of Px before this call
>> is executed.
>>
>> *Clearly computer science is incorrect on this point*
>> Computer science says that H must still return a value to Px even
>> though the call to H is not even executed because all deciders must
>> ALWAYS return to their caller.
>
> Computer science is correct on this point, what is incorrect is your
> implementation of H.
>
> /Flibble
>

So you are saying the a computer program that is never even executed
must still return a result?

--
Copyright 2022 Pete Olcott

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

On Sun, 28 Aug 2022 15:10:30 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/28/2022 3:02 PM, Mr Flibble wrote:
> > On Sun, 28 Aug 2022 14:47:08 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> Since Turing machines are mathematical objects that only exist in
> >> the mind people can have contradictory thus incoherent ideas about
> >> these abstract mathematical objects and never realize that their
> >> ideas are incoherent.
> >>
> >> When we study the theory of computation using physically existing
> >> machines such as the x86 architecture then the incoherent abstract
> >> ideas are shown to be incoherent in that they cannot be physically
> >> implemented.
> >>
> >> void Px(ptr x)
> >> {
> >> H(x, x);
> >> return;
> >> }
> >>
> >> int main()
> >> {
> >> Output("Input_Halts = ", H(Px, Px));
> >> }
> >>
> >> If a decider must always return a value whenever it is called this
> >> requires H to return a value to Px even though H is called in
> >> infinite recursion.
> >>
> >> This even requires that the function call from Px to H(Px,Px) must
> >> return a value to Px even if this function call to H is not even
> >> executed. In the physical model of computation it is an axiom the
> >> programs that are not executed never return values because it is
> >> physically impossible.
> >>
> >> When simulating halt decider H sees that Px is about to call
> >> H(Px,Px) in infinite recursion H aborts its simulation of Px
> >> before this call is executed.
> >>
> >> *Clearly computer science is incorrect on this point*
> >> Computer science says that H must still return a value to Px even
> >> though the call to H is not even executed because all deciders must
> >> ALWAYS return to their caller.
> >
> > Computer science is correct on this point, what is incorrect is your
> > implementation of H.
> >
> > /Flibble
> >
>
> So you are saying the a computer program that is never even executed
> must still return a result?

No, I am saying that your H isn't a halt decider.

/Flibble

On 8/28/22 3:47 PM, olcott wrote:
> Since Turing machines are mathematical objects that only exist in the
> mind people can have contradictory thus incoherent ideas about these
> abstract mathematical objects and never realize that their ideas are
> incoherent.

Please name ONE. If there is a contradiction, you should be able to
precisely state it, since the advantage of Mathematical objects is they
are very precisel defined.

>
> When we study the theory of computation using physically existing
> machines such as the x86 architecture then the incoherent abstract ideas
> are shown to be incoherent in that they cannot be physically implemented.

Yes, not all Mathematical idea can be physically implemented, like a
Halt Decider.

>
> void Px(ptr x)
> {
>   H(x, x);
>   return;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H(Px, Px));
> }
>
> If a decider must always return a value whenever it is called this
> requires H to return a value to Px even though H is called in infinite
> recursion.

As has been pointed out, it HASN'T been called in infinite Recursion.

The ACTUAL BEHAVIOR of the ACTUAL INPUT is:

(1) Px(Px) calls
(2) H(Px,Px) which simulates
(3) Px(Px) which it simulates to calling
(4) H(Px,Px)
(5) At this point (2) H(Px,Px) aborts its simulation and returns to (1)
(6) The (1) Px(Px) getting an answer from (2) H(Px,Px) then Halts.

So, no infinite recursion.

>
> This even requires that the function call from Px to H(Px,Px) must
> return a value to Px even if this function call to H is not even
> executed. In the physical model of computation it is an axiom the
> programs that are not executed never return values because it is
> physically impossible.

Where is this requirement?

>
> When simulating halt decider H sees that Px is about to call H(Px,Px) in
> infinite recursion H aborts its simulation of Px before this call is
> executed.

No it sees a call from Px(Px) to H(Px,Px) that it decides (INCORRECTLY)
will cause infinite recursion so H aborts its simulation, as programmed.

There is actually no infinite recursion, only faulty logic. The lack of
infinite recursion was shows above. H only decides on infinite recursion
becuase it was given a faulty rule to use.

Yes, it is because of that faulty logic/rule that the input halts, but
without the faulty logic H will just fail to answer, so fails to meet
its requirements.

>
> *Clearly computer science is incorrect on this point*
> Computer science says that H must still return a value to Px even though
> the call to H is not even executed because all deciders must ALWAYS
> return to their caller.
>
>

No, YOU are incorrect on this point.

And WHERE was the requirement for H to return a value to Px without a
call to H?

We HAD a call to H, you might stop the simulation at that point, which
is fine, there is no rule about how far H needs to simulate, just that
it is supposed to get the right answer. Note though, we know that the
complete simulation, which DOES agree with the behavior, WILL eventually
reach the return to Px, if H is a decider. H just doesn't use logic
compatible with this fact.

The problem is the design of H uses logic that assumes behavior out of a
call to H that doesn't match the actual behavior of the actual H that
exists. Thus it gets the wrong answer.

H needs to decide on the ACTUAL BEHAVIOR of the ACTUAL INPUT based on an
actual COMPLETE SIMULATION of that input (even if it isn't done by H).
The fact that it can't doesn't relieve it of the requirement to do so,
that just shows that an H that meets the requirements can not exist.

On 8/28/22 4:10 PM, olcott wrote:
> On 8/28/2022 3:02 PM, Mr Flibble wrote:
>> On Sun, 28 Aug 2022 14:47:08 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> Since Turing machines are mathematical objects that only exist in the
>>> mind people can have contradictory thus incoherent ideas about these
>>> abstract mathematical objects and never realize that their ideas are
>>> incoherent.
>>>
>>> When we study the theory of computation using physically existing
>>> machines such as the x86 architecture then the incoherent abstract
>>> ideas are shown to be incoherent in that they cannot be physically
>>> implemented.
>>>
>>> void Px(ptr x)
>>> {
>>>     H(x, x);
>>>     return;
>>> }
>>>
>>> int main()
>>> {
>>>     Output("Input_Halts = ", H(Px, Px));
>>> }
>>>
>>> If a decider must always return a value whenever it is called this
>>> requires H to return a value to Px even though H is called in
>>> infinite recursion.
>>>
>>> This even requires that the function call from Px to H(Px,Px) must
>>> return a value to Px even if this function call to H is not even
>>> executed. In the physical model of computation it is an axiom the
>>> programs that are not executed never return values because it is
>>> physically impossible.
>>>
>>> When simulating halt decider H sees that Px is about to call H(Px,Px)
>>> in infinite recursion H aborts its simulation of Px before this call
>>> is executed.
>>>
>>> *Clearly computer science is incorrect on this point*
>>> Computer science says that H must still return a value to Px even
>>> though the call to H is not even executed because all deciders must
>>> ALWAYS return to their caller.
>>
>> Computer science is correct on this point, what is incorrect is your
>> implementation of H.
>>
>> /Flibble
>>
>
> So you are saying the a computer program that is never even executed
> must still return a result?
>

The key point is we know what value it would return if executed.

On Sunday, 28 August 2022 at 22:10:37 UTC+2, olcott wrote:
> On 8/28/2022 3:02 PM, Mr Flibble wrote:
> > On Sun, 28 Aug 2022 14:47:08 -0500
> > olcott <No...@NoWhere.com> wrote:
> >
> >> Since Turing machines are mathematical objects that only exist in the
> >> mind people can have contradictory thus incoherent ideas about these
> >> abstract mathematical objects and never realize that their ideas are
> >> incoherent.
> >>
> >> When we study the theory of computation using physically existing
> >> machines such as the x86 architecture then the incoherent abstract
> >> ideas are shown to be incoherent in that they cannot be physically
> >> implemented.
> >>
> >> void Px(ptr x)
> >> {
> >> H(x, x);
> >> return;
> >> }
> >>
> >> int main()
> >> {
> >> Output("Input_Halts = ", H(Px, Px));
> >> }
> >>
> >> If a decider must always return a value whenever it is called this
> >> requires H to return a value to Px even though H is called in
> >> infinite recursion.
> >>
> >> This even requires that the function call from Px to H(Px,Px) must
> >> return a value to Px even if this function call to H is not even
> >> executed. In the physical model of computation it is an axiom the
> >> programs that are not executed never return values because it is
> >> physically impossible.
> >>
> >> When simulating halt decider H sees that Px is about to call H(Px,Px)
> >> in infinite recursion H aborts its simulation of Px before this call
> >> is executed.
> >>
> >> *Clearly computer science is incorrect on this point*
> >> Computer science says that H must still return a value to Px even
> >> though the call to H is not even executed because all deciders must
> >> ALWAYS return to their caller.
> >
> > Computer science is correct on this point, what is incorrect is your
> > implementation of H.
> >
> > /Flibble
> >
> So you are saying the a computer program that is never even executed
> must still return a result?

The "result" of a program that never returns is None!
This is equivalent of treating non-termination as an effect.

No problem - is just a definition.

On 8/28/2022 1:47 PM, olcott wrote:

<SNIP> idiotic posted.

Since you couldn't even write a TM that decides if a number, base one,
was even or odd, how do you justify a thread with this title?

I recently attended a seminar/discussion about what could be taught to
grade school (late grades) and high school kids that would introduce
them to Computer Science (not Computer Engineering). I suggested first
teach how to write Touring machines then guide them thru a proof of the
Halting Theorem. Most thought this a decent suggestion. Then I thought
of stupid you, a so called computer professional, and had to decide if
this was too difficult for grade school children or was it just you. I
think you have justified my conclusion.

Have you ever heard the story of Buncha the Lame? The whole village
laughed at him because he couldn't walk a straight line and was both
physically and mentally unable. One day with the whole village watching,
the clouds in the sky disappeared and the Band of the Angels appeared
playing God's music. And there was Buncha, now the Magnificent, marching
in perfect time and rhythm to the holy music.

Ever nutter on USENET thinks he's Buncha. Son that isn't you. The way
you think and reason is deeply flawed. So hubris, not divine guidance is
the explanation for decades of inanities.
--
Jeff Barnett

On Sunday, August 28, 2022 at 3:20:19 PM UTC-7, Jeff Barnett wrote:
> On 8/28/2022 1:47 PM, olcott wrote:
>
> <SNIP> idiotic posted.
>
> Since you couldn't even write a TM that decides if a number, base one,
> was even or odd, how do you justify a thread with this title?
>
> I recently attended a seminar/discussion about what could be taught to
> grade school (late grades) and high school kids that would introduce
> them to Computer Science (not Computer Engineering). I suggested first
> teach how to write Touring machines then guide them thru a proof of the
> Halting Theorem. Most thought this a decent suggestion. Then I thought
> of stupid you, a so called computer professional, and had to decide if
> this was too difficult for grade school children or was it just you. I
> think you have justified my conclusion.
>
> Have you ever heard the story of Buncha the Lame? The whole village
> laughed at him because he couldn't walk a straight line and was both
> physically and mentally unable. One day with the whole village watching,
> the clouds in the sky disappeared and the Band of the Angels appeared
> playing God's music. And there was Buncha, now the Magnificent, marching
> in perfect time and rhythm to the holy music.
>
> Ever nutter on USENET thinks he's Buncha. Son that isn't you. The way
> you think and reason is deeply flawed. So hubris, not divine guidance is
> the explanation for decades of inanities.
> --
> Jeff Barnett

Um, hey, guys. There pretty much isn't anything "computer science" which isn't about Turing Machines.
The "ignoramus" routine's getting a little old.

On 8/28/2022 3:16 PM, Richard Damon wrote:
>
> On 8/28/22 3:47 PM, olcott wrote:
>> Since Turing machines are mathematical objects that only exist in the
>> mind people can have contradictory thus incoherent ideas about these
>> abstract mathematical objects and never realize that their ideas are
>> incoherent.
>
> Please name ONE. If there is a contradiction, you should be able to
> precisely state it, since the advantage of Mathematical objects is they
> are very precisel defined.
>
>>
>> When we study the theory of computation using physically existing
>> machines such as the x86 architecture then the incoherent abstract
>> ideas are shown to be incoherent in that they cannot be physically
>> implemented.
>
> Yes, not all Mathematical idea can be physically implemented, like a
> Halt Decider.
>
>>
>> void Px(ptr x)
>> {
>>    H(x, x);
>>    return;
>> }
>>
>> int main()
>> {
>>    Output("Input_Halts = ", H(Px, Px));
>> }
>>
>> If a decider must always return a value whenever it is called this
>> requires H to return a value to Px even though H is called in infinite
>> recursion.
>
> As has been pointed out, it HASN'T been called in infinite Recursion.
>
> The ACTUAL BEHAVIOR of the ACTUAL INPUT is:
>
> (1) Px(Px) calls
> (2) H(Px,Px) which simulates
> (3) Px(Px) which it simulates to calling
> (4) H(Px,Px)
> (5) At this point (2) H(Px,Px) aborts its simulation and returns to (1)
> (6) The (1) Px(Px) getting an answer from (2) H(Px,Px) then Halts.
>
> So, no infinite recursion.
>
>>
>> This even requires that the function call from Px to H(Px,Px) must
>> return a value to Px even if this function call to H is not even
>> executed. In the physical model of computation it is an axiom the
>> programs that are not executed never return values because it is
>> physically impossible.
>
> Where is this requirement?
>
>>
>> When simulating halt decider H sees that Px is about to call H(Px,Px)
>> in infinite recursion H aborts its simulation of Px before this call
>> is executed.
>
> No it sees a call from Px(Px) to H(Px,Px) that it decides  (INCORRECTLY)
> will cause infinite recursion so H aborts its simulation, as programmed.
>
> There is actually no infinite recursion, only faulty logic. The lack of
> infinite recursion was shows above. H only decides on infinite recursion
> becuase it was given a faulty rule to use.
>
> Yes, it is because of that faulty logic/rule that the input halts, but
> without the faulty logic H will just fail to answer, so fails to meet
> its requirements.
>
>
>>
>> *Clearly computer science is incorrect on this point*
>> Computer science says that H must still return a value to Px even
>> though the call to H is not even executed because all deciders must
>> ALWAYS return to their caller.
>>
>>
>
> No, YOU are incorrect on this point.
>
> And WHERE was the requirement for H to return a value to Px without a
> call to H?

That came from you. You said that H must always return to Px even in the
case when H(Px,Px) aborts its simulation of Px before Px executes its
call to H(Px,Px).

--
Copyright 2022 Pete Olcott

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

On 8/28/22 7:33 PM, Jeffrey Rubard wrote:
> On Sunday, August 28, 2022 at 3:20:19 PM UTC-7, Jeff Barnett wrote:
>> On 8/28/2022 1:47 PM, olcott wrote:
>>
>> <SNIP> idiotic posted.
>>
>> Since you couldn't even write a TM that decides if a number, base one,
>> was even or odd, how do you justify a thread with this title?
>>
>> I recently attended a seminar/discussion about what could be taught to
>> grade school (late grades) and high school kids that would introduce
>> them to Computer Science (not Computer Engineering). I suggested first
>> teach how to write Touring machines then guide them thru a proof of the
>> Halting Theorem. Most thought this a decent suggestion. Then I thought
>> of stupid you, a so called computer professional, and had to decide if
>> this was too difficult for grade school children or was it just you. I
>> think you have justified my conclusion.
>>
>> Have you ever heard the story of Buncha the Lame? The whole village
>> laughed at him because he couldn't walk a straight line and was both
>> physically and mentally unable. One day with the whole village watching,
>> the clouds in the sky disappeared and the Band of the Angels appeared
>> playing God's music. And there was Buncha, now the Magnificent, marching
>> in perfect time and rhythm to the holy music.
>>
>> Ever nutter on USENET thinks he's Buncha. Son that isn't you. The way
>> you think and reason is deeply flawed. So hubris, not divine guidance is
>> the explanation for decades of inanities.
>> --
>> Jeff Barnett
>
> Um, hey, guys. There pretty much isn't anything "computer science" which isn't about Turing Machines.
> The "ignoramus" routine's getting a little old.

Except for the stuff that looks at other architectures, like the RASP
machine, and comparing how much "better" they are than a Turing Machine
in executing algorithms (Faster or Smaller)

Or the architectures that are weaker than Turing Machines and what they
can't do compared to Turing Machines.

On 8/28/2022 5:20 PM, Jeff Barnett wrote:
> On 8/28/2022 1:47 PM, olcott wrote:
>
> <SNIP> idiotic posted.
>
> Since you couldn't even write a TM that decides if a number, base one,
> was even or odd, how do you justify a thread with this title?
>

I told you I was very sick from chemo therapy.
Would it help my credibility if I finished this?

I have been in the middle of fully translating
my system to Linux. I have most of this done now.

--
Copyright 2022 Pete Olcott

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

On 8/28/22 7:54 PM, olcott wrote:
> On 8/28/2022 3:16 PM, Richard Damon wrote:
>>
>> On 8/28/22 3:47 PM, olcott wrote:
>>> Since Turing machines are mathematical objects that only exist in the
>>> mind people can have contradictory thus incoherent ideas about these
>>> abstract mathematical objects and never realize that their ideas are
>>> incoherent.
>>
>> Please name ONE. If there is a contradiction, you should be able to
>> precisely state it, since the advantage of Mathematical objects is
>> they are very precisel defined.
>>
>>>
>>> When we study the theory of computation using physically existing
>>> machines such as the x86 architecture then the incoherent abstract
>>> ideas are shown to be incoherent in that they cannot be physically
>>> implemented.
>>
>> Yes, not all Mathematical idea can be physically implemented, like a
>> Halt Decider.
>>
>>>
>>> void Px(ptr x)
>>> {
>>>    H(x, x);
>>>    return;
>>> }
>>>
>>> int main()
>>> {
>>>    Output("Input_Halts = ", H(Px, Px));
>>> }
>>>
>>> If a decider must always return a value whenever it is called this
>>> requires H to return a value to Px even though H is called in
>>> infinite recursion.
>>
>> As has been pointed out, it HASN'T been called in infinite Recursion.
>>
>> The ACTUAL BEHAVIOR of the ACTUAL INPUT is:
>>
>> (1) Px(Px) calls
>> (2) H(Px,Px) which simulates
>> (3) Px(Px) which it simulates to calling
>> (4) H(Px,Px)
>> (5) At this point (2) H(Px,Px) aborts its simulation and returns to (1)
>> (6) The (1) Px(Px) getting an answer from (2) H(Px,Px) then Halts.
>>
>> So, no infinite recursion.
>>
>>>
>>> This even requires that the function call from Px to H(Px,Px) must
>>> return a value to Px even if this function call to H is not even
>>> executed. In the physical model of computation it is an axiom the
>>> programs that are not executed never return values because it is
>>> physically impossible.
>>
>> Where is this requirement?
>>
>>>
>>> When simulating halt decider H sees that Px is about to call H(Px,Px)
>>> in infinite recursion H aborts its simulation of Px before this call
>>> is executed.
>>
>> No it sees a call from Px(Px) to H(Px,Px) that it decides
>> (INCORRECTLY) will cause infinite recursion so H aborts its
>> simulation, as programmed.
>>
>> There is actually no infinite recursion, only faulty logic. The lack
>> of infinite recursion was shows above. H only decides on infinite
>> recursion becuase it was given a faulty rule to use.
>>
>> Yes, it is because of that faulty logic/rule that the input halts, but
>> without the faulty logic H will just fail to answer, so fails to meet
>> its requirements.
>>
>>
>>>
>>> *Clearly computer science is incorrect on this point*
>>> Computer science says that H must still return a value to Px even
>>> though the call to H is not even executed because all deciders must
>>> ALWAYS return to their caller.
>>>
>>>
>>
>> No, YOU are incorrect on this point.
>>
>> And WHERE was the requirement for H to return a value to Px without a
>> call to H?
>
> That came from you. You said that H must always return to Px even in the
> case when H(Px,Px) aborts its simulation of Px before Px executes its
> call to H(Px,Px).
>

Yes, the COMPLETE simulation of the input will see that call and return,
yes. If it saw the Call, it will see the Return.

The PARTIAL simulation done by H doesn't need to.

Do you disagree?

Or do you believe that there can be an call to H(Px,Px) that never
returns to its caller even after an unbounded number of steps simulated?

Remember, a Pure Function behaves the same for ALL calls to it, so if
one call doesn't return, no calls return.

That ISN'T what you said though, you said if the call never was
executed, H still needed to return, but every return that is required
WAS preceeded by a call.

You don't seem to be able to parse your sentences well.

On 8/28/2022 3:44 PM, Skep Dick wrote:
> On Sunday, 28 August 2022 at 22:10:37 UTC+2, olcott wrote:
>> On 8/28/2022 3:02 PM, Mr Flibble wrote:
>>> On Sun, 28 Aug 2022 14:47:08 -0500
>>> olcott <No...@NoWhere.com> wrote:
>>>
>>>> Since Turing machines are mathematical objects that only exist in the
>>>> mind people can have contradictory thus incoherent ideas about these
>>>> abstract mathematical objects and never realize that their ideas are
>>>> incoherent.
>>>>
>>>> When we study the theory of computation using physically existing
>>>> machines such as the x86 architecture then the incoherent abstract
>>>> ideas are shown to be incoherent in that they cannot be physically
>>>> implemented.
>>>>
>>>> void Px(ptr x)
>>>> {
>>>> H(x, x);
>>>> return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", H(Px, Px));
>>>> }
>>>>
>>>> If a decider must always return a value whenever it is called this
>>>> requires H to return a value to Px even though H is called in
>>>> infinite recursion.
>>>>
>>>> This even requires that the function call from Px to H(Px,Px) must
>>>> return a value to Px even if this function call to H is not even
>>>> executed. In the physical model of computation it is an axiom the
>>>> programs that are not executed never return values because it is
>>>> physically impossible.
>>>>
>>>> When simulating halt decider H sees that Px is about to call H(Px,Px)
>>>> in infinite recursion H aborts its simulation of Px before this call
>>>> is executed.
>>>>
>>>> *Clearly computer science is incorrect on this point*
>>>> Computer science says that H must still return a value to Px even
>>>> though the call to H is not even executed because all deciders must
>>>> ALWAYS return to their caller.
>>>
>>> Computer science is correct on this point, what is incorrect is your
>>> implementation of H.
>>>
>>> /Flibble
>>>
>> So you are saying the a computer program that is never even executed
>> must still return a result?
>
> The "result" of a program that never returns is None!
> This is equivalent of treating non-termination as an effect.
>
> No problem - is just a definition.

H(Px,Px) returns 0 to main. Some people have said that the when Px calls
H(Px,Px) that H must return a value to Px even though this function call
from Px to H is never executed.

On other words some people are saying that a program that is never
executed must still produce an output.

--
Copyright 2022 Pete Olcott

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

On 8/28/2022 7:02 PM, Richard Damon wrote:
> On 8/28/22 7:54 PM, olcott wrote:
>> On 8/28/2022 3:16 PM, Richard Damon wrote:
>>>
>>> On 8/28/22 3:47 PM, olcott wrote:
>>>> Since Turing machines are mathematical objects that only exist in
>>>> the mind people can have contradictory thus incoherent ideas about
>>>> these abstract mathematical objects and never realize that their
>>>> ideas are incoherent.
>>>
>>> Please name ONE. If there is a contradiction, you should be able to
>>> precisely state it, since the advantage of Mathematical objects is
>>> they are very precisel defined.
>>>
>>>>
>>>> When we study the theory of computation using physically existing
>>>> machines such as the x86 architecture then the incoherent abstract
>>>> ideas are shown to be incoherent in that they cannot be physically
>>>> implemented.
>>>
>>> Yes, not all Mathematical idea can be physically implemented, like a
>>> Halt Decider.
>>>
>>>>
>>>> void Px(ptr x)
>>>> {
>>>>    H(x, x);
>>>>    return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>    Output("Input_Halts = ", H(Px, Px));
>>>> }
>>>>
>>>> If a decider must always return a value whenever it is called this
>>>> requires H to return a value to Px even though H is called in
>>>> infinite recursion.
>>>
>>> As has been pointed out, it HASN'T been called in infinite Recursion.
>>>
>>> The ACTUAL BEHAVIOR of the ACTUAL INPUT is:
>>>
>>> (1) Px(Px) calls
>>> (2) H(Px,Px) which simulates
>>> (3) Px(Px) which it simulates to calling
>>> (4) H(Px,Px)
>>> (5) At this point (2) H(Px,Px) aborts its simulation and returns to (1)
>>> (6) The (1) Px(Px) getting an answer from (2) H(Px,Px) then Halts.
>>>
>>> So, no infinite recursion.
>>>
>>>>
>>>> This even requires that the function call from Px to H(Px,Px) must
>>>> return a value to Px even if this function call to H is not even
>>>> executed. In the physical model of computation it is an axiom the
>>>> programs that are not executed never return values because it is
>>>> physically impossible.
>>>
>>> Where is this requirement?
>>>
>>>>
>>>> When simulating halt decider H sees that Px is about to call
>>>> H(Px,Px) in infinite recursion H aborts its simulation of Px before
>>>> this call is executed.
>>>
>>> No it sees a call from Px(Px) to H(Px,Px) that it decides
>>> (INCORRECTLY) will cause infinite recursion so H aborts its
>>> simulation, as programmed.
>>>
>>> There is actually no infinite recursion, only faulty logic. The lack
>>> of infinite recursion was shows above. H only decides on infinite
>>> recursion becuase it was given a faulty rule to use.
>>>
>>> Yes, it is because of that faulty logic/rule that the input halts,
>>> but without the faulty logic H will just fail to answer, so fails to
>>> meet its requirements.
>>>
>>>
>>>>
>>>> *Clearly computer science is incorrect on this point*
>>>> Computer science says that H must still return a value to Px even
>>>> though the call to H is not even executed because all deciders must
>>>> ALWAYS return to their caller.
>>>>
>>>>
>>>
>>> No, YOU are incorrect on this point.
>>>
>>> And WHERE was the requirement for H to return a value to Px without a
>>> call to H?
>>
>> That came from you. You said that H must always return to Px even in
>> the case when H(Px,Px) aborts its simulation of Px before Px executes
>> its call to H(Px,Px).
>>
>
> Yes, the COMPLETE simulation of the input will see that call and return,
> yes. If it saw the Call, it will see the Return.
>

So you are saying that UTM(Px,Px) will return to Px?

void Px(ptr x)
{ int Halt_Status = UTM(x, x);
return;
}

int main()
{ Output("Input_Halts = ", H(P, P));
}

--
Copyright 2022 Pete Olcott

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

On 8/28/22 8:07 PM, olcott wrote:
> On 8/28/2022 3:44 PM, Skep Dick wrote:
>> On Sunday, 28 August 2022 at 22:10:37 UTC+2, olcott wrote:
>>> On 8/28/2022 3:02 PM, Mr Flibble wrote:
>>>> On Sun, 28 Aug 2022 14:47:08 -0500
>>>> olcott <No...@NoWhere.com> wrote:
>>>>
>>>>> Since Turing machines are mathematical objects that only exist in the
>>>>> mind people can have contradictory thus incoherent ideas about these
>>>>> abstract mathematical objects and never realize that their ideas are
>>>>> incoherent.
>>>>>
>>>>> When we study the theory of computation using physically existing
>>>>> machines such as the x86 architecture then the incoherent abstract
>>>>> ideas are shown to be incoherent in that they cannot be physically
>>>>> implemented.
>>>>>
>>>>> void Px(ptr x)
>>>>> {
>>>>> H(x, x);
>>>>> return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>> Output("Input_Halts = ", H(Px, Px));
>>>>> }
>>>>>
>>>>> If a decider must always return a value whenever it is called this
>>>>> requires H to return a value to Px even though H is called in
>>>>> infinite recursion.
>>>>>
>>>>> This even requires that the function call from Px to H(Px,Px) must
>>>>> return a value to Px even if this function call to H is not even
>>>>> executed. In the physical model of computation it is an axiom the
>>>>> programs that are not executed never return values because it is
>>>>> physically impossible.
>>>>>
>>>>> When simulating halt decider H sees that Px is about to call H(Px,Px)
>>>>> in infinite recursion H aborts its simulation of Px before this call
>>>>> is executed.
>>>>>
>>>>> *Clearly computer science is incorrect on this point*
>>>>> Computer science says that H must still return a value to Px even
>>>>> though the call to H is not even executed because all deciders must
>>>>> ALWAYS return to their caller.
>>>>
>>>> Computer science is correct on this point, what is incorrect is your
>>>> implementation of H.
>>>>
>>>> /Flibble
>>>>
>>> So you are saying the a computer program that is never even executed
>>> must still return a result?
>>
>> The "result" of a program that never returns is None!
>> This is equivalent of treating non-termination as an effect.
>>
>> No problem - is just a definition.
>
> H(Px,Px) returns 0 to main. Some people have said that the when Px calls
> H(Px,Px) that H must return a value to Px even though this function call
> from Px to H is never executed.

Except that in the ACTUAL BEHAVIOR of the input, the call IS executed.

You are just confusiong the ACTUAL BEHAVIOR with the behavior that H
determines.

>
> On other words some people are saying that a program that is never
> executed must still produce an output.
>

No, just that we can sometimes know the behavior of a program even if we
haven't actually executed it.

For instance, we KNOW that Px(Px) will Halt since we KNOW that H(Px,Px)
returns an answer. That is provable by simple inspection.

In the same way, we KNOW that P(P) will Halt since we KNOW (from your
demonstration) that H(P,P) returns 0, thus we KNOW that H was wrong.

On 8/28/22 8:10 PM, olcott wrote:
> On 8/28/2022 7:02 PM, Richard Damon wrote:
>> On 8/28/22 7:54 PM, olcott wrote:
>>> On 8/28/2022 3:16 PM, Richard Damon wrote:
>>>>
>>>> On 8/28/22 3:47 PM, olcott wrote:
>>>>> Since Turing machines are mathematical objects that only exist in
>>>>> the mind people can have contradictory thus incoherent ideas about
>>>>> these abstract mathematical objects and never realize that their
>>>>> ideas are incoherent.
>>>>
>>>> Please name ONE. If there is a contradiction, you should be able to
>>>> precisely state it, since the advantage of Mathematical objects is
>>>> they are very precisel defined.
>>>>
>>>>>
>>>>> When we study the theory of computation using physically existing
>>>>> machines such as the x86 architecture then the incoherent abstract
>>>>> ideas are shown to be incoherent in that they cannot be physically
>>>>> implemented.
>>>>
>>>> Yes, not all Mathematical idea can be physically implemented, like a
>>>> Halt Decider.
>>>>
>>>>>
>>>>> void Px(ptr x)
>>>>> {
>>>>>    H(x, x);
>>>>>    return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>    Output("Input_Halts = ", H(Px, Px));
>>>>> }
>>>>>
>>>>> If a decider must always return a value whenever it is called this
>>>>> requires H to return a value to Px even though H is called in
>>>>> infinite recursion.
>>>>
>>>> As has been pointed out, it HASN'T been called in infinite Recursion.
>>>>
>>>> The ACTUAL BEHAVIOR of the ACTUAL INPUT is:
>>>>
>>>> (1) Px(Px) calls
>>>> (2) H(Px,Px) which simulates
>>>> (3) Px(Px) which it simulates to calling
>>>> (4) H(Px,Px)
>>>> (5) At this point (2) H(Px,Px) aborts its simulation and returns to (1)
>>>> (6) The (1) Px(Px) getting an answer from (2) H(Px,Px) then Halts.
>>>>
>>>> So, no infinite recursion.
>>>>
>>>>>
>>>>> This even requires that the function call from Px to H(Px,Px) must
>>>>> return a value to Px even if this function call to H is not even
>>>>> executed. In the physical model of computation it is an axiom the
>>>>> programs that are not executed never return values because it is
>>>>> physically impossible.
>>>>
>>>> Where is this requirement?
>>>>
>>>>>
>>>>> When simulating halt decider H sees that Px is about to call
>>>>> H(Px,Px) in infinite recursion H aborts its simulation of Px before
>>>>> this call is executed.
>>>>
>>>> No it sees a call from Px(Px) to H(Px,Px) that it decides
>>>> (INCORRECTLY) will cause infinite recursion so H aborts its
>>>> simulation, as programmed.
>>>>
>>>> There is actually no infinite recursion, only faulty logic. The lack
>>>> of infinite recursion was shows above. H only decides on infinite
>>>> recursion becuase it was given a faulty rule to use.
>>>>
>>>> Yes, it is because of that faulty logic/rule that the input halts,
>>>> but without the faulty logic H will just fail to answer, so fails to
>>>> meet its requirements.
>>>>
>>>>
>>>>>
>>>>> *Clearly computer science is incorrect on this point*
>>>>> Computer science says that H must still return a value to Px even
>>>>> though the call to H is not even executed because all deciders must
>>>>> ALWAYS return to their caller.
>>>>>
>>>>>
>>>>
>>>> No, YOU are incorrect on this point.
>>>>
>>>> And WHERE was the requirement for H to return a value to Px without
>>>> a call to H?
>>>
>>> That came from you. You said that H must always return to Px even in
>>> the case when H(Px,Px) aborts its simulation of Px before Px executes
>>> its call to H(Px,Px).
>>>
>>
>> Yes, the COMPLETE simulation of the input will see that call and
>> return, yes. If it saw the Call, it will see the Return.
>>
>
> So you are saying that UTM(Px,Px) will return to Px?

No, but thst wasn't the definition of Px.

That is just your Strawman / Red Herring.

You sure seem to want to PROVE that you are a total idiot.

>
> void Px(ptr x)
> {
>   int Halt_Status = UTM(x, x);
>   return;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H(P, P));
> }
>
>
>

Remember Px was DEFINED as:

vod Px(ptr x)
{ H(x,x);
return;
}

We can write the test program for your decider:

int main()
{ Output("Input Halts = ", H(Px,Px));
UTM(Px,Px);
Output(" And Px(Px) actually Halts");
}

Try it, and see.

On 8/28/22 8:01 PM, olcott wrote:
> On 8/28/2022 5:20 PM, Jeff Barnett wrote:
>> On 8/28/2022 1:47 PM, olcott wrote:
>>
>> <SNIP> idiotic posted.
>>
>> Since you couldn't even write a TM that decides if a number, base one,
>> was even or odd, how do you justify a thread with this title?
>>
>
> I told you I was very sick from chemo therapy.
> Would it help my credibility if I finished this?
>
> I have been in the middle of fully translating
> my system to Linux. I have most of this done now.
>
>

It might let you see where your problem is.

You seem very good at getting yourself side tracked from doing the
actually important things.

On 8/28/2022 7:47 PM, Richard Damon wrote:
> On 8/28/22 8:07 PM, olcott wrote:
>> On 8/28/2022 3:44 PM, Skep Dick wrote:
>>> On Sunday, 28 August 2022 at 22:10:37 UTC+2, olcott wrote:
>>>> On 8/28/2022 3:02 PM, Mr Flibble wrote:
>>>>> On Sun, 28 Aug 2022 14:47:08 -0500
>>>>> olcott <No...@NoWhere.com> wrote:
>>>>>
>>>>>> Since Turing machines are mathematical objects that only exist in the
>>>>>> mind people can have contradictory thus incoherent ideas about these
>>>>>> abstract mathematical objects and never realize that their ideas are
>>>>>> incoherent.
>>>>>>
>>>>>> When we study the theory of computation using physically existing
>>>>>> machines such as the x86 architecture then the incoherent abstract
>>>>>> ideas are shown to be incoherent in that they cannot be physically
>>>>>> implemented.
>>>>>>
>>>>>> void Px(ptr x)
>>>>>> {
>>>>>> H(x, x);
>>>>>> return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> Output("Input_Halts = ", H(Px, Px));
>>>>>> }
>>>>>>
>>>>>> If a decider must always return a value whenever it is called this
>>>>>> requires H to return a value to Px even though H is called in
>>>>>> infinite recursion.
>>>>>>
>>>>>> This even requires that the function call from Px to H(Px,Px) must
>>>>>> return a value to Px even if this function call to H is not even
>>>>>> executed. In the physical model of computation it is an axiom the
>>>>>> programs that are not executed never return values because it is
>>>>>> physically impossible.
>>>>>>
>>>>>> When simulating halt decider H sees that Px is about to call H(Px,Px)
>>>>>> in infinite recursion H aborts its simulation of Px before this call
>>>>>> is executed.
>>>>>>
>>>>>> *Clearly computer science is incorrect on this point*
>>>>>> Computer science says that H must still return a value to Px even
>>>>>> though the call to H is not even executed because all deciders must
>>>>>> ALWAYS return to their caller.
>>>>>
>>>>> Computer science is correct on this point, what is incorrect is your
>>>>> implementation of H.
>>>>>
>>>>> /Flibble
>>>>>
>>>> So you are saying the a computer program that is never even executed
>>>> must still return a result?
>>>
>>> The "result" of a program that never returns is None!
>>> This is equivalent of treating non-termination as an effect.
>>>
>>> No problem - is just a definition.
>>
>> H(Px,Px) returns 0 to main. Some people have said that the when Px
>> calls H(Px,Px) that H must return a value to Px even though this
>> function call from Px to H is never executed.
>
> Except that in the ACTUAL BEHAVIOR of the input, the call IS executed.
>
> You are just confusiong the ACTUAL BEHAVIOR with the behavior that H
> determines.
>

You said that H must always return a result to its caller even if this
call is never actually executed.

--
Copyright 2022 Pete Olcott

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

On 8/28/22 9:15 PM, olcott wrote:
> On 8/28/2022 7:47 PM, Richard Damon wrote:
>> On 8/28/22 8:07 PM, olcott wrote:
>>> On 8/28/2022 3:44 PM, Skep Dick wrote:
>>>> On Sunday, 28 August 2022 at 22:10:37 UTC+2, olcott wrote:
>>>>> On 8/28/2022 3:02 PM, Mr Flibble wrote:
>>>>>> On Sun, 28 Aug 2022 14:47:08 -0500
>>>>>> olcott <No...@NoWhere.com> wrote:
>>>>>>
>>>>>>> Since Turing machines are mathematical objects that only exist in
>>>>>>> the
>>>>>>> mind people can have contradictory thus incoherent ideas about these
>>>>>>> abstract mathematical objects and never realize that their ideas are
>>>>>>> incoherent.
>>>>>>>
>>>>>>> When we study the theory of computation using physically existing
>>>>>>> machines such as the x86 architecture then the incoherent abstract
>>>>>>> ideas are shown to be incoherent in that they cannot be physically
>>>>>>> implemented.
>>>>>>>
>>>>>>> void Px(ptr x)
>>>>>>> {
>>>>>>> H(x, x);
>>>>>>> return;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> Output("Input_Halts = ", H(Px, Px));
>>>>>>> }
>>>>>>>
>>>>>>> If a decider must always return a value whenever it is called this
>>>>>>> requires H to return a value to Px even though H is called in
>>>>>>> infinite recursion.
>>>>>>>
>>>>>>> This even requires that the function call from Px to H(Px,Px) must
>>>>>>> return a value to Px even if this function call to H is not even
>>>>>>> executed. In the physical model of computation it is an axiom the
>>>>>>> programs that are not executed never return values because it is
>>>>>>> physically impossible.
>>>>>>>
>>>>>>> When simulating halt decider H sees that Px is about to call
>>>>>>> H(Px,Px)
>>>>>>> in infinite recursion H aborts its simulation of Px before this call
>>>>>>> is executed.
>>>>>>>
>>>>>>> *Clearly computer science is incorrect on this point*
>>>>>>> Computer science says that H must still return a value to Px even
>>>>>>> though the call to H is not even executed because all deciders must
>>>>>>> ALWAYS return to their caller.
>>>>>>
>>>>>> Computer science is correct on this point, what is incorrect is your
>>>>>> implementation of H.
>>>>>>
>>>>>> /Flibble
>>>>>>
>>>>> So you are saying the a computer program that is never even executed
>>>>> must still return a result?
>>>>
>>>> The "result" of a program that never returns is None!
>>>> This is equivalent of treating non-termination as an effect.
>>>>
>>>> No problem - is just a definition.
>>>
>>> H(Px,Px) returns 0 to main. Some people have said that the when Px
>>> calls H(Px,Px) that H must return a value to Px even though this
>>> function call from Px to H is never executed.
>>
>> Except that in the ACTUAL BEHAVIOR of the input, the call IS executed.
>>
>> You are just confusiong the ACTUAL BEHAVIOR with the behavior that H
>> determines.
>>
>
> You said that H must always return a result to its caller even if this
> call is never actually executed.
>

You don't HAVE a caller unless you execute the call instruction.

Do you really not know the meaning of this simple of a word?

On 8/28/2022 7:51 PM, Richard Damon wrote:
> On 8/28/22 8:10 PM, olcott wrote:
>> On 8/28/2022 7:02 PM, Richard Damon wrote:
>>> On 8/28/22 7:54 PM, olcott wrote:
>>>> On 8/28/2022 3:16 PM, Richard Damon wrote:
>>>>>
>>>>> On 8/28/22 3:47 PM, olcott wrote:
>>>>>> Since Turing machines are mathematical objects that only exist in
>>>>>> the mind people can have contradictory thus incoherent ideas about
>>>>>> these abstract mathematical objects and never realize that their
>>>>>> ideas are incoherent.
>>>>>
>>>>> Please name ONE. If there is a contradiction, you should be able to
>>>>> precisely state it, since the advantage of Mathematical objects is
>>>>> they are very precisel defined.
>>>>>
>>>>>>
>>>>>> When we study the theory of computation using physically existing
>>>>>> machines such as the x86 architecture then the incoherent abstract
>>>>>> ideas are shown to be incoherent in that they cannot be physically
>>>>>> implemented.
>>>>>
>>>>> Yes, not all Mathematical idea can be physically implemented, like
>>>>> a Halt Decider.
>>>>>
>>>>>>
>>>>>> void Px(ptr x)
>>>>>> {
>>>>>>    H(x, x);
>>>>>>    return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>    Output("Input_Halts = ", H(Px, Px));
>>>>>> }
>>>>>>
>>>>>> If a decider must always return a value whenever it is called this
>>>>>> requires H to return a value to Px even though H is called in
>>>>>> infinite recursion.
>>>>>
>>>>> As has been pointed out, it HASN'T been called in infinite Recursion.
>>>>>
>>>>> The ACTUAL BEHAVIOR of the ACTUAL INPUT is:
>>>>>
>>>>> (1) Px(Px) calls
>>>>> (2) H(Px,Px) which simulates
>>>>> (3) Px(Px) which it simulates to calling
>>>>> (4) H(Px,Px)
>>>>> (5) At this point (2) H(Px,Px) aborts its simulation and returns to
>>>>> (1)
>>>>> (6) The (1) Px(Px) getting an answer from (2) H(Px,Px) then Halts.
>>>>>
>>>>> So, no infinite recursion.
>>>>>
>>>>>>
>>>>>> This even requires that the function call from Px to H(Px,Px) must
>>>>>> return a value to Px even if this function call to H is not even
>>>>>> executed. In the physical model of computation it is an axiom the
>>>>>> programs that are not executed never return values because it is
>>>>>> physically impossible.
>>>>>
>>>>> Where is this requirement?
>>>>>
>>>>>>
>>>>>> When simulating halt decider H sees that Px is about to call
>>>>>> H(Px,Px) in infinite recursion H aborts its simulation of Px
>>>>>> before this call is executed.
>>>>>
>>>>> No it sees a call from Px(Px) to H(Px,Px) that it decides
>>>>> (INCORRECTLY) will cause infinite recursion so H aborts its
>>>>> simulation, as programmed.
>>>>>
>>>>> There is actually no infinite recursion, only faulty logic. The
>>>>> lack of infinite recursion was shows above. H only decides on
>>>>> infinite recursion becuase it was given a faulty rule to use.
>>>>>
>>>>> Yes, it is because of that faulty logic/rule that the input halts,
>>>>> but without the faulty logic H will just fail to answer, so fails
>>>>> to meet its requirements.
>>>>>
>>>>>
>>>>>>
>>>>>> *Clearly computer science is incorrect on this point*
>>>>>> Computer science says that H must still return a value to Px even
>>>>>> though the call to H is not even executed because all deciders
>>>>>> must ALWAYS return to their caller.
>>>>>>
>>>>>>
>>>>>
>>>>> No, YOU are incorrect on this point.
>>>>>
>>>>> And WHERE was the requirement for H to return a value to Px without
>>>>> a call to H?
>>>>
>>>> That came from you. You said that H must always return to Px even in
>>>> the case when H(Px,Px) aborts its simulation of Px before Px
>>>> executes its call to H(Px,Px).
>>>>
>>>
>>> Yes, the COMPLETE simulation of the input will see that call and
>>> return, yes. If it saw the Call, it will see the Return.
>>>
>>
>> So you are saying that UTM(Px,Px) will return to Px?
>
> No, but thst wasn't the definition of Px.
>

void Px(ptr x)
{ int Halt_Status = UTM(x, x);
return;
}

Then you are contradicting yourself. You said that only a UTM provides a
COMPLETE simulation and now you are disagreeing with what you said.

A complete simulation of the input to H(Px,Px) is only possible if H is
replaced by a UTM. If H is not replaced by a UTM then a complete
simulation of the inpit to H(Px,Px) is not possible.

--
Copyright 2022 Pete Olcott

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

On 8/28/2022 7:53 PM, Richard Damon wrote:
> On 8/28/22 8:01 PM, olcott wrote:
>> On 8/28/2022 5:20 PM, Jeff Barnett wrote:
>>> On 8/28/2022 1:47 PM, olcott wrote:
>>>
>>> <SNIP> idiotic posted.
>>>
>>> Since you couldn't even write a TM that decides if a number, base
>>> one, was even or odd, how do you justify a thread with this title?
>>>
>>
>> I told you I was very sick from chemo therapy.
>> Would it help my credibility if I finished this?
>>
>> I have been in the middle of fully translating
>> my system to Linux. I have most of this done now.
>>
>>
>
> It might let you see where your problem is.
>
> You seem very good at getting yourself side tracked from doing the
> actually important things.

If people were to simply review my work objectively without the bias
that I must be wrong they would see that I am correct.

The problem is that they review my work on the basis of dogma that they
take as infallible thus refuse to seriously consider the reasoning that
proves this dogma is incorrect.

Textbooks say that H(P,P) must be based on the behavior of P(P).

Correct reasoning says that H(P,P) must be based on the behavior of the
correct simulation of the input to H in the hypothetical case where H
never aborted the simulation of its input.

Because the dogma is considered to be the infallible word of God the
correct reasoning is dismissed out-of-hand without review.

--
Copyright 2022 Pete Olcott

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

On 8/28/2022 8:19 PM, Richard Damon wrote:
>
> On 8/28/22 9:15 PM, olcott wrote:
>> On 8/28/2022 7:47 PM, Richard Damon wrote:
>>> On 8/28/22 8:07 PM, olcott wrote:
>>>> On 8/28/2022 3:44 PM, Skep Dick wrote:
>>>>> On Sunday, 28 August 2022 at 22:10:37 UTC+2, olcott wrote:
>>>>>> On 8/28/2022 3:02 PM, Mr Flibble wrote:
>>>>>>> On Sun, 28 Aug 2022 14:47:08 -0500
>>>>>>> olcott <No...@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> Since Turing machines are mathematical objects that only exist
>>>>>>>> in the
>>>>>>>> mind people can have contradictory thus incoherent ideas about
>>>>>>>> these
>>>>>>>> abstract mathematical objects and never realize that their ideas
>>>>>>>> are
>>>>>>>> incoherent.
>>>>>>>>
>>>>>>>> When we study the theory of computation using physically existing
>>>>>>>> machines such as the x86 architecture then the incoherent abstract
>>>>>>>> ideas are shown to be incoherent in that they cannot be physically
>>>>>>>> implemented.
>>>>>>>>
>>>>>>>> void Px(ptr x)
>>>>>>>> {
>>>>>>>> H(x, x);
>>>>>>>> return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>> Output("Input_Halts = ", H(Px, Px));
>>>>>>>> }
>>>>>>>>
>>>>>>>> If a decider must always return a value whenever it is called this
>>>>>>>> requires H to return a value to Px even though H is called in
>>>>>>>> infinite recursion.
>>>>>>>>
>>>>>>>> This even requires that the function call from Px to H(Px,Px) must
>>>>>>>> return a value to Px even if this function call to H is not even
>>>>>>>> executed. In the physical model of computation it is an axiom the
>>>>>>>> programs that are not executed never return values because it is
>>>>>>>> physically impossible.
>>>>>>>>
>>>>>>>> When simulating halt decider H sees that Px is about to call
>>>>>>>> H(Px,Px)
>>>>>>>> in infinite recursion H aborts its simulation of Px before this
>>>>>>>> call
>>>>>>>> is executed.
>>>>>>>>
>>>>>>>> *Clearly computer science is incorrect on this point*
>>>>>>>> Computer science says that H must still return a value to Px even
>>>>>>>> though the call to H is not even executed because all deciders must
>>>>>>>> ALWAYS return to their caller.
>>>>>>>
>>>>>>> Computer science is correct on this point, what is incorrect is your
>>>>>>> implementation of H.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>> So you are saying the a computer program that is never even executed
>>>>>> must still return a result?
>>>>>
>>>>> The "result" of a program that never returns is None!
>>>>> This is equivalent of treating non-termination as an effect.
>>>>>
>>>>> No problem - is just a definition.
>>>>
>>>> H(Px,Px) returns 0 to main. Some people have said that the when Px
>>>> calls H(Px,Px) that H must return a value to Px even though this
>>>> function call from Px to H is never executed.
>>>
>>> Except that in the ACTUAL BEHAVIOR of the input, the call IS executed.
>>>
>>> You are just confusiong the ACTUAL BEHAVIOR with the behavior that H
>>> determines.
>>>
>>
>> You said that H must always return a result to its caller even if this
>> call is never actually executed.
>>
>
> You don't HAVE a caller unless you execute the call instruction.
>
> Do you really not know the meaning of this simple of a word?

You are the one that said H is not a pure function thus not Turing
computable on the basis that H(Px,Px) does not return a value to Px even
though the call to H(Px,Px) is never executed.

Are you admitting that you were wrong about this?

--
Copyright 2022 Pete Olcott

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

On 8/28/2022 7:02 PM, Richard Damon wrote:
> On 8/28/22 7:54 PM, olcott wrote:
>> On 8/28/2022 3:16 PM, Richard Damon wrote:
>>>
>>> On 8/28/22 3:47 PM, olcott wrote:
>>>> Since Turing machines are mathematical objects that only exist in
>>>> the mind people can have contradictory thus incoherent ideas about
>>>> these abstract mathematical objects and never realize that their
>>>> ideas are incoherent.
>>>
>>> Please name ONE. If there is a contradiction, you should be able to
>>> precisely state it, since the advantage of Mathematical objects is
>>> they are very precisel defined.
>>>
>>>>
>>>> When we study the theory of computation using physically existing
>>>> machines such as the x86 architecture then the incoherent abstract
>>>> ideas are shown to be incoherent in that they cannot be physically
>>>> implemented.
>>>
>>> Yes, not all Mathematical idea can be physically implemented, like a
>>> Halt Decider.
>>>
>>>>
>>>> void Px(ptr x)
>>>> {
>>>>    H(x, x);
>>>>    return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>    Output("Input_Halts = ", H(Px, Px));
>>>> }
>>>>
>>>> If a decider must always return a value whenever it is called this
>>>> requires H to return a value to Px even though H is called in
>>>> infinite recursion.
>>>
>>> As has been pointed out, it HASN'T been called in infinite Recursion.
>>>
>>> The ACTUAL BEHAVIOR of the ACTUAL INPUT is:
>>>
>>> (1) Px(Px) calls
>>> (2) H(Px,Px) which simulates
>>> (3) Px(Px) which it simulates to calling
>>> (4) H(Px,Px)
>>> (5) At this point (2) H(Px,Px) aborts its simulation and returns to (1)
>>> (6) The (1) Px(Px) getting an answer from (2) H(Px,Px) then Halts.
>>>
>>> So, no infinite recursion.
>>>
>>>>
>>>> This even requires that the function call from Px to H(Px,Px) must
>>>> return a value to Px even if this function call to H is not even
>>>> executed. In the physical model of computation it is an axiom the
>>>> programs that are not executed never return values because it is
>>>> physically impossible.
>>>
>>> Where is this requirement?
>>>
>>>>
>>>> When simulating halt decider H sees that Px is about to call
>>>> H(Px,Px) in infinite recursion H aborts its simulation of Px before
>>>> this call is executed.
>>>
>>> No it sees a call from Px(Px) to H(Px,Px) that it decides
>>> (INCORRECTLY) will cause infinite recursion so H aborts its
>>> simulation, as programmed.
>>>
>>> There is actually no infinite recursion, only faulty logic. The lack
>>> of infinite recursion was shows above. H only decides on infinite
>>> recursion becuase it was given a faulty rule to use.
>>>
>>> Yes, it is because of that faulty logic/rule that the input halts,
>>> but without the faulty logic H will just fail to answer, so fails to
>>> meet its requirements.
>>>
>>>
>>>>
>>>> *Clearly computer science is incorrect on this point*
>>>> Computer science says that H must still return a value to Px even
>>>> though the call to H is not even executed because all deciders must
>>>> ALWAYS return to their caller.
>>>>
>>>>
>>>
>>> No, YOU are incorrect on this point.
>>>
>>> And WHERE was the requirement for H to return a value to Px without a
>>> call to H?
>>
>> That came from you. You said that H must always return to Px even in
>> the case when H(Px,Px) aborts its simulation of Px before Px executes
>> its call to H(Px,Px).
>>
>
> Yes, the COMPLETE simulation of the input will see that call and return,
> yes. If it saw the Call, it will see the Return.
In what exact case do you imagine that H(Px,Px) returns a value to its
simulated input?

--
Copyright 2022 Pete Olcott

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