--
Copyright 2022 Pete Olcott

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

On Sat, 11 Jun 2022 00:03:37 -0500
olcott <NoOne@NoWhere.com> wrote:

"H(P,P) as a pure function of its inputs is easy"

If H as a "pure function" doesn't return a result to its caller then it
isn't a halt decider.

/Flibble

On 6/11/2022 7:03 AM, Mr Flibble wrote:
> On Sat, 11 Jun 2022 00:03:37 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
> "H(P,P) as a pure function of its inputs is easy"
>
> If H as a "pure function" doesn't return a result to its caller then it
> isn't a halt decider.
>
> /Flibble
>

The first H(P,P) that is invoked always returns a value to its caller.
Subsequent recursive invocations are a part of infinitely nested
simulation that must be aborted.

--
Copyright 2022 Pete Olcott

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

On Sat, 11 Jun 2022 09:35:02 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/11/2022 7:03 AM, Mr Flibble wrote:
> > On Sat, 11 Jun 2022 00:03:37 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> > "H(P,P) as a pure function of its inputs is easy"
> >
> > If H as a "pure function" doesn't return a result to its caller
> > then it isn't a halt decider.
> >
> > /Flibble
> >
>
> The first H(P,P) that is invoked always returns a value to its caller.
> Subsequent recursive invocations are a part of infinitely nested
> simulation that must be aborted.
Nope. A pure function always returns the same value for the same inputs:

"the function return values are identical for identical arguments" --
https://en.wikipedia.org/wiki/Pure_function

/Flibble

On 6/11/2022 9:40 AM, Mr Flibble wrote:
> On Sat, 11 Jun 2022 09:35:02 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/11/2022 7:03 AM, Mr Flibble wrote:
>>> On Sat, 11 Jun 2022 00:03:37 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>> "H(P,P) as a pure function of its inputs is easy"
>>>
>>> If H as a "pure function" doesn't return a result to its caller
>>> then it isn't a halt decider.
>>>
>>> /Flibble
>>>
>>
>> The first H(P,P) that is invoked always returns a value to its caller.
>> Subsequent recursive invocations are a part of infinitely nested
>> simulation that must be aborted.
>
> Nope. A pure function always returns the same value for the same inputs:
>

One can assume this when one has never bothered to think infinitely
nested simulation all the way through. Parroting things that textbooks
say is of no use because textbooks have never addressed this.

The idea of a simulating halt decider that correctly detects infinitely
nested simulation of the conventional halting problem proof
counter-examples is brand new with me so you won't find any textbook
that discusses it.

The outer-most H(P,P) is a pure function of its inputs.

> "the function return values are identical for identical arguments" --
> https://en.wikipedia.org/wiki/Pure_function
>
> /Flibble
>

--
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 6/11/22 10:35 AM, olcott wrote:
> On 6/11/2022 7:03 AM, Mr Flibble wrote:
>> On Sat, 11 Jun 2022 00:03:37 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>> "H(P,P) as a pure function of its inputs is easy"
>>
>> If H as a "pure function" doesn't return a result to its caller then it
>> isn't a halt decider.
>>
>> /Flibble
>>
>
> The first H(P,P) that is invoked always returns a value to its caller.
> Subsequent recursive invocations are a part of infinitely nested
> simulation that must be aborted.
>

Then it isn't a Computation based on an actual finite definite
deterministic algrorithm based solely on its inputs.

Also, it isn't a pure function, as a pure function is DEFINED as a
function whose behavior is only determined by its inputs, and which has
no observable side effect.

If main calling H(P,P) gets back a 0, while main calling P calling
H(P,P) gets infinite recursion, H has just proved itself to NOT be a
PURE RUNCITON, as its behavior just changed based on something besides
it's inputs (that would be the two pointers P).

Care to explain HOW H is a pure function when it doesn't meet the
definition?

Or, are you still going by the broken definition that a correct
simulation doesn't need to match the behavior of the thing it is actualy
simulating?

On Sat, 11 Jun 2022 09:52:34 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/11/2022 9:40 AM, Mr Flibble wrote:
> > On Sat, 11 Jun 2022 09:35:02 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/11/2022 7:03 AM, Mr Flibble wrote:
> >>> On Sat, 11 Jun 2022 00:03:37 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>> "H(P,P) as a pure function of its inputs is easy"
> >>>
> >>> If H as a "pure function" doesn't return a result to its caller
> >>> then it isn't a halt decider.
> >>>
> >>> /Flibble
> >>>
> >>
> >> The first H(P,P) that is invoked always returns a value to its
> >> caller. Subsequent recursive invocations are a part of infinitely
> >> nested simulation that must be aborted.
> >
> > Nope. A pure function always returns the same value for the same
> > inputs:
>
> One can assume this when one has never bothered to think infinitely
> nested simulation all the way through. Parroting things that
> textbooks say is of no use because textbooks have never addressed
> this.
>
> The idea of a simulating halt decider that correctly detects
> infinitely nested simulation of the conventional halting problem
> proof counter-examples is brand new with me so you won't find any
> textbook that discusses it.
>
> The outer-most H(P,P) is a pure function of its inputs.

Then the H that P calls is a different H because as I just stated, "a
pure function always returns the same value for the same inputs".

You can't just redefine accepted computer science concepts such as
what constitutes a pure function.

> > "the function return values are identical for identical arguments"
> > -- https://en.wikipedia.org/wiki/Pure_function

/Flibble

On 6/11/2022 9:52 AM, Richard Damon wrote:
>
> On 6/11/22 10:35 AM, olcott wrote:
>> On 6/11/2022 7:03 AM, Mr Flibble wrote:
>>> On Sat, 11 Jun 2022 00:03:37 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>> "H(P,P) as a pure function of its inputs is easy"
>>>
>>> If H as a "pure function" doesn't return a result to its caller then it
>>> isn't a halt decider.
>>>
>>> /Flibble
>>>
>>
>> The first H(P,P) that is invoked always returns a value to its caller.
>> Subsequent recursive invocations are a part of infinitely nested
>> simulation that must be aborted.
>>
>
> Then it isn't a Computation based on an actual finite definite
> deterministic algrorithm based solely on its inputs.
>
> Also, it isn't a pure function, as a pure function is DEFINED as a
> function whose behavior is only determined by its inputs, and which has
> no observable side effect.
>
> If main calling H(P,P) gets back a 0, while main calling P calling
> H(P,P) gets infinite recursion, H has just proved itself to NOT be a
> PURE RUNCITON, as its behavior just changed based on something besides
> it's inputs (that would be the two pointers P).
>
> Care to explain HOW H is a pure function when it doesn't meet the
> definition?
>

No one ever bothered to think through the idea that a simulating halt
decider would detect infinitely nested simulation of its HP inputs all
the way through ever before.

> Or, are you still going by the broken definition that a correct
> simulation doesn't need to match the behavior of the thing it is actualy
> simulating?

--
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 6/11/2022 9:55 AM, Mr Flibble wrote:
> On Sat, 11 Jun 2022 09:52:34 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/11/2022 9:40 AM, Mr Flibble wrote:
>>> On Sat, 11 Jun 2022 09:35:02 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/11/2022 7:03 AM, Mr Flibble wrote:
>>>>> On Sat, 11 Jun 2022 00:03:37 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>> "H(P,P) as a pure function of its inputs is easy"
>>>>>
>>>>> If H as a "pure function" doesn't return a result to its caller
>>>>> then it isn't a halt decider.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> The first H(P,P) that is invoked always returns a value to its
>>>> caller. Subsequent recursive invocations are a part of infinitely
>>>> nested simulation that must be aborted.
>>>
>>> Nope. A pure function always returns the same value for the same
>>> inputs:
>>
>> One can assume this when one has never bothered to think infinitely
>> nested simulation all the way through. Parroting things that
>> textbooks say is of no use because textbooks have never addressed
>> this.
>>
>> The idea of a simulating halt decider that correctly detects
>> infinitely nested simulation of the conventional halting problem
>> proof counter-examples is brand new with me so you won't find any
>> textbook that discusses it.
>>
>> The outer-most H(P,P) is a pure function of its inputs.
>
> Then the H that P calls is a different H because as I just stated, "a
> pure function always returns the same value for the same inputs".
>
> You can't just redefine accepted computer science concepts such as
> what constitutes a pure function.
>

It is the case that the outer H(P,P) is a pure function of its inputs.

>>> "the function return values are identical for identical arguments"
>>> -- https://en.wikipedia.org/wiki/Pure_function
>
> /Flibble
>

--
Copyright 2022 Pete Olcott

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

On Sat, 11 Jun 2022 09:59:10 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/11/2022 9:55 AM, Mr Flibble wrote:
> > On Sat, 11 Jun 2022 09:52:34 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/11/2022 9:40 AM, Mr Flibble wrote:
> >>> On Sat, 11 Jun 2022 09:35:02 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/11/2022 7:03 AM, Mr Flibble wrote:
> >>>>> On Sat, 11 Jun 2022 00:03:37 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>> "H(P,P) as a pure function of its inputs is easy"
> >>>>>
> >>>>> If H as a "pure function" doesn't return a result to its caller
> >>>>> then it isn't a halt decider.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> The first H(P,P) that is invoked always returns a value to its
> >>>> caller. Subsequent recursive invocations are a part of infinitely
> >>>> nested simulation that must be aborted.
> >>>
> >>> Nope. A pure function always returns the same value for the same
> >>> inputs:
> >>
> >> One can assume this when one has never bothered to think infinitely
> >> nested simulation all the way through. Parroting things that
> >> textbooks say is of no use because textbooks have never addressed
> >> this.
> >>
> >> The idea of a simulating halt decider that correctly detects
> >> infinitely nested simulation of the conventional halting problem
> >> proof counter-examples is brand new with me so you won't find any
> >> textbook that discusses it.
> >>
> >> The outer-most H(P,P) is a pure function of its inputs.
> >
> > Then the H that P calls is a different H because as I just stated,
> > "a pure function always returns the same value for the same inputs".
> >
> > You can't just redefine accepted computer science concepts such as
> > what constitutes a pure function.
> >
>
> It is the case that the outer H(P,P) is a pure function of its inputs.

So your tactic now is simply to ignore what people say and just repeat
yourself? What is the point of doing that? Seems like a waste of time
to me.

/Flibble

On 6/11/22 10:52 AM, olcott wrote:
> On 6/11/2022 9:40 AM, Mr Flibble wrote:
>> On Sat, 11 Jun 2022 09:35:02 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> On 6/11/2022 7:03 AM, Mr Flibble wrote:
>>>> On Sat, 11 Jun 2022 00:03:37 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>
>>>> "H(P,P) as a pure function of its inputs is easy"
>>>>
>>>> If H as a "pure function" doesn't return a result to its caller
>>>> then it isn't a halt decider.
>>>>
>>>> /Flibble
>>>>
>>>
>>> The first H(P,P) that is invoked always returns a value to its caller.
>>> Subsequent recursive invocations are a part of infinitely nested
>>> simulation that must be aborted.
>> Nope. A pure function always returns the same value for the same inputs:
>>
>
> One can assume this when one has never bothered to think infinitely
> nested simulation all the way through. Parroting things that textbooks
> say is of no use because textbooks have never addressed this.
>
> The idea of a simulating halt decider that correctly detects infinitely
> nested simulation of the conventional halting problem proof
> counter-examples is brand new with me so you won't find any textbook
> that discusses it.
>
> The outer-most H(P,P) is a pure function of its inputs.

But not ALL H(P,P)? Then it isn't a pure function at all, an y ou are
just shoing that you don;t understand what you are talking about.

Purity isn't a property of a specific call, but of the function as a whole.

H either is, or is not, a "Pure Function". If it is, then ALL calls to H
with the same parameters behave the same, if not, it just isn't "Pure".

DEFINITION.

You know, the things that Truth is based on.

You claim that textbook never addressed your idea of simulation, but the
rule of the field don't allow for an exception. YOu are just showing how
ignorant you are of the acual rules of the field.

In other words, you are just being STUPID.

You would need to actually PROVE, based on a REAL FORMAL proof that your
claims are true, which you can't.

DEFINTINITION are DEFINITIONS.

Maybe, because of the way the definition of a Pure Function works, it is
impossible to make a "Simulating Halt Decider" as you envision it as a
pure function because the infinite recursion makes it act differently in
different circumstances, that just means it isn't a pure function.

It also means it fails to be a Computation as defined by Computation
Theory, and doesn't have a Turing Machine Equivalent, and so can't be a
counter example for Linz, since that is talking about Turing Machines.

>
>> "the function return values are identical for identical arguments" --
>> https://en.wikipedia.org/wiki/Pure_function
>>
>> /Flibble
>>
>
>

On 6/11/2022 10:01 AM, Mr Flibble wrote:
> On Sat, 11 Jun 2022 09:59:10 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/11/2022 9:55 AM, Mr Flibble wrote:
>>> On Sat, 11 Jun 2022 09:52:34 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/11/2022 9:40 AM, Mr Flibble wrote:
>>>>> On Sat, 11 Jun 2022 09:35:02 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/11/2022 7:03 AM, Mr Flibble wrote:
>>>>>>> On Sat, 11 Jun 2022 00:03:37 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>> "H(P,P) as a pure function of its inputs is easy"
>>>>>>>
>>>>>>> If H as a "pure function" doesn't return a result to its caller
>>>>>>> then it isn't a halt decider.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> The first H(P,P) that is invoked always returns a value to its
>>>>>> caller. Subsequent recursive invocations are a part of infinitely
>>>>>> nested simulation that must be aborted.
>>>>>
>>>>> Nope. A pure function always returns the same value for the same
>>>>> inputs:
>>>>
>>>> One can assume this when one has never bothered to think infinitely
>>>> nested simulation all the way through. Parroting things that
>>>> textbooks say is of no use because textbooks have never addressed
>>>> this.
>>>>
>>>> The idea of a simulating halt decider that correctly detects
>>>> infinitely nested simulation of the conventional halting problem
>>>> proof counter-examples is brand new with me so you won't find any
>>>> textbook that discusses it.
>>>>
>>>> The outer-most H(P,P) is a pure function of its inputs.
>>>
>>> Then the H that P calls is a different H because as I just stated,
>>> "a pure function always returns the same value for the same inputs".
>>>
>>> You can't just redefine accepted computer science concepts such as
>>> what constitutes a pure function.
>>>
>>
>> It is the case that the outer H(P,P) is a pure function of its inputs.
>
> So your tactic now is simply to ignore what people say and just repeat
> yourself? What is the point of doing that? Seems like a waste of time
> to me.
>
> /Flibble
>

We need actual PhD computer scientists that are experts in the theory of
computation to evaluate these things. You guys are merely spouting off
misonceptions.

--
Copyright 2022 Pete Olcott

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

On Sat, 11 Jun 2022 10:11:37 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/11/2022 10:01 AM, Mr Flibble wrote:
> > On Sat, 11 Jun 2022 09:59:10 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/11/2022 9:55 AM, Mr Flibble wrote:
> >>> On Sat, 11 Jun 2022 09:52:34 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/11/2022 9:40 AM, Mr Flibble wrote:
> >>>>> On Sat, 11 Jun 2022 09:35:02 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/11/2022 7:03 AM, Mr Flibble wrote:
> >>>>>>> On Sat, 11 Jun 2022 00:03:37 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>> "H(P,P) as a pure function of its inputs is easy"
> >>>>>>>
> >>>>>>> If H as a "pure function" doesn't return a result to its
> >>>>>>> caller then it isn't a halt decider.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> The first H(P,P) that is invoked always returns a value to its
> >>>>>> caller. Subsequent recursive invocations are a part of
> >>>>>> infinitely nested simulation that must be aborted.
> >>>>>
> >>>>> Nope. A pure function always returns the same value for the same
> >>>>> inputs:
> >>>>
> >>>> One can assume this when one has never bothered to think
> >>>> infinitely nested simulation all the way through. Parroting
> >>>> things that textbooks say is of no use because textbooks have
> >>>> never addressed this.
> >>>>
> >>>> The idea of a simulating halt decider that correctly detects
> >>>> infinitely nested simulation of the conventional halting problem
> >>>> proof counter-examples is brand new with me so you won't find any
> >>>> textbook that discusses it.
> >>>>
> >>>> The outer-most H(P,P) is a pure function of its inputs.
> >>>
> >>> Then the H that P calls is a different H because as I just stated,
> >>> "a pure function always returns the same value for the same
> >>> inputs".
> >>>
> >>> You can't just redefine accepted computer science concepts such as
> >>> what constitutes a pure function.
> >>>
> >>
> >> It is the case that the outer H(P,P) is a pure function of its
> >> inputs.
> >
> > So your tactic now is simply to ignore what people say and just
> > repeat yourself? What is the point of doing that? Seems like a
> > waste of time to me.
> >
> > /Flibble
> >
>
> We need actual PhD computer scientists that are experts in the theory
> of computation to evaluate these things. You guys are merely spouting
> off misonceptions.
LOL. Appeal to authority, a logical fallacy, mate.

/Flibble

On 6/11/2022 10:02 AM, Richard Damon wrote:
> On 6/11/22 10:52 AM, olcott wrote:
>> On 6/11/2022 9:40 AM, Mr Flibble wrote:
>>> On Sat, 11 Jun 2022 09:35:02 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/11/2022 7:03 AM, Mr Flibble wrote:
>>>>> On Sat, 11 Jun 2022 00:03:37 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>> "H(P,P) as a pure function of its inputs is easy"
>>>>>
>>>>> If H as a "pure function" doesn't return a result to its caller
>>>>> then it isn't a halt decider.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> The first H(P,P) that is invoked always returns a value to its caller.
>>>> Subsequent recursive invocations are a part of infinitely nested
>>>> simulation that must be aborted.
>>> Nope. A pure function always returns the same value for the same inputs:
>>>
>>
>> One can assume this when one has never bothered to think infinitely
>> nested simulation all the way through. Parroting things that textbooks
>> say is of no use because textbooks have never addressed this.
>>
>> The idea of a simulating halt decider that correctly detects
>> infinitely nested simulation of the conventional halting problem proof
>> counter-examples is brand new with me so you won't find any textbook
>> that discusses it.
>>
>> The outer-most H(P,P) is a pure function of its inputs.
>
> But not ALL H(P,P)? Then it isn't a pure function at all, an y ou are
> just shoing that you don;t understand what you are talking about.

We need actual PhD computer scientists that are experts in the theory of
computation to evaluate these things. You guys are merely spouting off
misconceptions.

No theory of computation PhD computer scientist has ever analyzed the
concept of a simulating halt decider being applied to the HP
counter-example inputs ALL THE WAY THROUGH.

--
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 6/11/22 10:57 AM, olcott wrote:
> On 6/11/2022 9:52 AM, Richard Damon wrote:
>>
>> On 6/11/22 10:35 AM, olcott wrote:
>>> On 6/11/2022 7:03 AM, Mr Flibble wrote:
>>>> On Sat, 11 Jun 2022 00:03:37 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>
>>>> "H(P,P) as a pure function of its inputs is easy"
>>>>
>>>> If H as a "pure function" doesn't return a result to its caller then it
>>>> isn't a halt decider.
>>>>
>>>> /Flibble
>>>>
>>>
>>> The first H(P,P) that is invoked always returns a value to its caller.
>>> Subsequent recursive invocations are a part of infinitely nested
>>> simulation that must be aborted.
>>>
>>
>> Then it isn't a Computation based on an actual finite definite
>> deterministic algrorithm based solely on its inputs.
>>
>> Also, it isn't a pure function, as a pure function is DEFINED as a
>> function whose behavior is only determined by its inputs, and which
>> has no observable side effect.
>>
>> If main calling H(P,P) gets back a 0, while main calling P calling
>> H(P,P) gets infinite recursion, H has just proved itself to NOT be a
>> PURE RUNCITON, as its behavior just changed based on something besides
>> it's inputs (that would be the two pointers P).
>>
>> Care to explain HOW H is a pure function when it doesn't meet the
>> definition?
>>
>
> No one ever bothered to think through the idea that a simulating halt
> decider would detect infinitely nested simulation of its HP inputs all
> the way through ever before.
>

So, no answer.

It doesn't matter if anyone thought about this particular case if the
were able to disprove it in the general case. Linz proof (built from
Turing's) applies to ANY Halt Decider, even a "Simulating Halt Decider"
as long as that thing is properly in the class of things that are "Halt
Deciders". If someone can prove something for ALL Cats, then it applies
t your cat Rag-a-Muffin, no matter how unique you think it is, if you
cat is actually a cat.

Your H, that returns 0 from the call to H(P,P) from the call in main,
but gets into an infinite recursion when called from P, just PROVES that
it isn't actually a "Pure Function". THAT IS A DEFINITION.

You don't get to ignore the definition. PERIOD.

You are just showing that you don't know what the words actually mean,
that you don't care about what the words actually mean, and that you
will lie when you need to to try to make you point sound plausible, when
it is just false.

YOU HAVE FAILED, and wasted decades of your life.

>> Or, are you still going by the broken definition that a correct
>> simulation doesn't need to match the behavior of the thing it is
>> actualy simulating?
>
>

On 6/11/2022 10:12 AM, Mr Flibble wrote:
> On Sat, 11 Jun 2022 10:11:37 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/11/2022 10:01 AM, Mr Flibble wrote:
>>> On Sat, 11 Jun 2022 09:59:10 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/11/2022 9:55 AM, Mr Flibble wrote:
>>>>> On Sat, 11 Jun 2022 09:52:34 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/11/2022 9:40 AM, Mr Flibble wrote:
>>>>>>> On Sat, 11 Jun 2022 09:35:02 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/11/2022 7:03 AM, Mr Flibble wrote:
>>>>>>>>> On Sat, 11 Jun 2022 00:03:37 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>> "H(P,P) as a pure function of its inputs is easy"
>>>>>>>>>
>>>>>>>>> If H as a "pure function" doesn't return a result to its
>>>>>>>>> caller then it isn't a halt decider.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> The first H(P,P) that is invoked always returns a value to its
>>>>>>>> caller. Subsequent recursive invocations are a part of
>>>>>>>> infinitely nested simulation that must be aborted.
>>>>>>>
>>>>>>> Nope. A pure function always returns the same value for the same
>>>>>>> inputs:
>>>>>>
>>>>>> One can assume this when one has never bothered to think
>>>>>> infinitely nested simulation all the way through. Parroting
>>>>>> things that textbooks say is of no use because textbooks have
>>>>>> never addressed this.
>>>>>>
>>>>>> The idea of a simulating halt decider that correctly detects
>>>>>> infinitely nested simulation of the conventional halting problem
>>>>>> proof counter-examples is brand new with me so you won't find any
>>>>>> textbook that discusses it.
>>>>>>
>>>>>> The outer-most H(P,P) is a pure function of its inputs.
>>>>>
>>>>> Then the H that P calls is a different H because as I just stated,
>>>>> "a pure function always returns the same value for the same
>>>>> inputs".
>>>>>
>>>>> You can't just redefine accepted computer science concepts such as
>>>>> what constitutes a pure function.
>>>>>
>>>>
>>>> It is the case that the outer H(P,P) is a pure function of its
>>>> inputs.
>>>
>>> So your tactic now is simply to ignore what people say and just
>>> repeat yourself? What is the point of doing that? Seems like a
>>> waste of time to me.
>>>
>>> /Flibble
>>>
>>
>> We need actual PhD computer scientists that are experts in the theory
>> of computation to evaluate these things. You guys are merely spouting
>> off misonceptions.
>
> LOL. Appeal to authority, a logical fallacy, mate.
>
> /Flibble
>

People that only understand these things from the very shallow
perspective of learned-by-rote can't see any of the relevant details.

The best that they can do is parrot the words of others never realizing
that these words do not apply to this case. No one has ever examined
this case before.

--
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 6/11/2022 10:17 AM, Richard Damon wrote:
> On 6/11/22 10:57 AM, olcott wrote:
>> On 6/11/2022 9:52 AM, Richard Damon wrote:
>>>
>>> On 6/11/22 10:35 AM, olcott wrote:
>>>> On 6/11/2022 7:03 AM, Mr Flibble wrote:
>>>>> On Sat, 11 Jun 2022 00:03:37 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>> "H(P,P) as a pure function of its inputs is easy"
>>>>>
>>>>> If H as a "pure function" doesn't return a result to its caller
>>>>> then it
>>>>> isn't a halt decider.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> The first H(P,P) that is invoked always returns a value to its caller.
>>>> Subsequent recursive invocations are a part of infinitely nested
>>>> simulation that must be aborted.
>>>>
>>>
>>> Then it isn't a Computation based on an actual finite definite
>>> deterministic algrorithm based solely on its inputs.
>>>
>>> Also, it isn't a pure function, as a pure function is DEFINED as a
>>> function whose behavior is only determined by its inputs, and which
>>> has no observable side effect.
>>>
>>> If main calling H(P,P) gets back a 0, while main calling P calling
>>> H(P,P) gets infinite recursion, H has just proved itself to NOT be a
>>> PURE RUNCITON, as its behavior just changed based on something
>>> besides it's inputs (that would be the two pointers P).
>>>
>>> Care to explain HOW H is a pure function when it doesn't meet the
>>> definition?
>>>
>>
>> No one ever bothered to think through the idea that a simulating halt
>> decider would detect infinitely nested simulation of its HP inputs all
>> the way through ever before.
>>
>
> So, no answer.
>
> It doesn't matter if anyone thought about this particular case if the
> were able to disprove it in the general case.

When this case correctly refutes the general case then the general case
has been refuted.

--
Copyright 2022 Pete Olcott

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

On Sat, 11 Jun 2022 10:18:14 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/11/2022 10:12 AM, Mr Flibble wrote:
> > On Sat, 11 Jun 2022 10:11:37 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/11/2022 10:01 AM, Mr Flibble wrote:
> >>> On Sat, 11 Jun 2022 09:59:10 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/11/2022 9:55 AM, Mr Flibble wrote:
> >>>>> On Sat, 11 Jun 2022 09:52:34 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/11/2022 9:40 AM, Mr Flibble wrote:
> >>>>>>> On Sat, 11 Jun 2022 09:35:02 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 6/11/2022 7:03 AM, Mr Flibble wrote:
> >>>>>>>>> On Sat, 11 Jun 2022 00:03:37 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>> "H(P,P) as a pure function of its inputs is easy"
> >>>>>>>>>
> >>>>>>>>> If H as a "pure function" doesn't return a result to its
> >>>>>>>>> caller then it isn't a halt decider.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> The first H(P,P) that is invoked always returns a value to
> >>>>>>>> its caller. Subsequent recursive invocations are a part of
> >>>>>>>> infinitely nested simulation that must be aborted.
> >>>>>>>
> >>>>>>> Nope. A pure function always returns the same value for the
> >>>>>>> same inputs:
> >>>>>>
> >>>>>> One can assume this when one has never bothered to think
> >>>>>> infinitely nested simulation all the way through. Parroting
> >>>>>> things that textbooks say is of no use because textbooks have
> >>>>>> never addressed this.
> >>>>>>
> >>>>>> The idea of a simulating halt decider that correctly detects
> >>>>>> infinitely nested simulation of the conventional halting
> >>>>>> problem proof counter-examples is brand new with me so you
> >>>>>> won't find any textbook that discusses it.
> >>>>>>
> >>>>>> The outer-most H(P,P) is a pure function of its inputs.
> >>>>>
> >>>>> Then the H that P calls is a different H because as I just
> >>>>> stated, "a pure function always returns the same value for the
> >>>>> same inputs".
> >>>>>
> >>>>> You can't just redefine accepted computer science concepts such
> >>>>> as what constitutes a pure function.
> >>>>>
> >>>>
> >>>> It is the case that the outer H(P,P) is a pure function of its
> >>>> inputs.
> >>>
> >>> So your tactic now is simply to ignore what people say and just
> >>> repeat yourself? What is the point of doing that? Seems like a
> >>> waste of time to me.
> >>>
> >>> /Flibble
> >>>
> >>
> >> We need actual PhD computer scientists that are experts in the
> >> theory of computation to evaluate these things. You guys are
> >> merely spouting off misonceptions.
> >
> > LOL. Appeal to authority, a logical fallacy, mate.
> >
> > /Flibble
> >
>
> People that only understand these things from the very shallow
> perspective of learned-by-rote can't see any of the relevant details.
>
> The best that they can do is parrot the words of others never
> realizing that these words do not apply to this case. No one has ever
> examined this case before.
More repetition and refusal to engage in reasoned debate. You've got
nothing.

/Flibble

On 6/11/2022 10:19 AM, Mr Flibble wrote:
> On Sat, 11 Jun 2022 10:18:14 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/11/2022 10:12 AM, Mr Flibble wrote:
>>> On Sat, 11 Jun 2022 10:11:37 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/11/2022 10:01 AM, Mr Flibble wrote:
>>>>> On Sat, 11 Jun 2022 09:59:10 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/11/2022 9:55 AM, Mr Flibble wrote:
>>>>>>> On Sat, 11 Jun 2022 09:52:34 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/11/2022 9:40 AM, Mr Flibble wrote:
>>>>>>>>> On Sat, 11 Jun 2022 09:35:02 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 6/11/2022 7:03 AM, Mr Flibble wrote:
>>>>>>>>>>> On Sat, 11 Jun 2022 00:03:37 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>> "H(P,P) as a pure function of its inputs is easy"
>>>>>>>>>>>
>>>>>>>>>>> If H as a "pure function" doesn't return a result to its
>>>>>>>>>>> caller then it isn't a halt decider.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The first H(P,P) that is invoked always returns a value to
>>>>>>>>>> its caller. Subsequent recursive invocations are a part of
>>>>>>>>>> infinitely nested simulation that must be aborted.
>>>>>>>>>
>>>>>>>>> Nope. A pure function always returns the same value for the
>>>>>>>>> same inputs:
>>>>>>>>
>>>>>>>> One can assume this when one has never bothered to think
>>>>>>>> infinitely nested simulation all the way through. Parroting
>>>>>>>> things that textbooks say is of no use because textbooks have
>>>>>>>> never addressed this.
>>>>>>>>
>>>>>>>> The idea of a simulating halt decider that correctly detects
>>>>>>>> infinitely nested simulation of the conventional halting
>>>>>>>> problem proof counter-examples is brand new with me so you
>>>>>>>> won't find any textbook that discusses it.
>>>>>>>>
>>>>>>>> The outer-most H(P,P) is a pure function of its inputs.
>>>>>>>
>>>>>>> Then the H that P calls is a different H because as I just
>>>>>>> stated, "a pure function always returns the same value for the
>>>>>>> same inputs".
>>>>>>>
>>>>>>> You can't just redefine accepted computer science concepts such
>>>>>>> as what constitutes a pure function.
>>>>>>>
>>>>>>
>>>>>> It is the case that the outer H(P,P) is a pure function of its
>>>>>> inputs.
>>>>>
>>>>> So your tactic now is simply to ignore what people say and just
>>>>> repeat yourself? What is the point of doing that? Seems like a
>>>>> waste of time to me.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> We need actual PhD computer scientists that are experts in the
>>>> theory of computation to evaluate these things. You guys are
>>>> merely spouting off misonceptions.
>>>
>>> LOL. Appeal to authority, a logical fallacy, mate.
>>>
>>> /Flibble
>>>
>>
>> People that only understand these things from the very shallow
>> perspective of learned-by-rote can't see any of the relevant details.
>>
>> The best that they can do is parrot the words of others never
>> realizing that these words do not apply to this case. No one has ever
>> examined this case before.
>
> More repetition and refusal to engage in reasoned debate. You've got
> nothing.
>
> /Flibble
>

You are spouting off things that are not true and too ignorant to
understand that they are not true.

--
Copyright 2022 Pete Olcott

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

On Sat, 11 Jun 2022 10:29:06 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/11/2022 10:19 AM, Mr Flibble wrote:
> > On Sat, 11 Jun 2022 10:18:14 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/11/2022 10:12 AM, Mr Flibble wrote:
> >>> On Sat, 11 Jun 2022 10:11:37 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/11/2022 10:01 AM, Mr Flibble wrote:
> >>>>> On Sat, 11 Jun 2022 09:59:10 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/11/2022 9:55 AM, Mr Flibble wrote:
> >>>>>>> On Sat, 11 Jun 2022 09:52:34 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 6/11/2022 9:40 AM, Mr Flibble wrote:
> >>>>>>>>> On Sat, 11 Jun 2022 09:35:02 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 6/11/2022 7:03 AM, Mr Flibble wrote:
> >>>>>>>>>>> On Sat, 11 Jun 2022 00:03:37 -0500
> >>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>> "H(P,P) as a pure function of its inputs is easy"
> >>>>>>>>>>>
> >>>>>>>>>>> If H as a "pure function" doesn't return a result to its
> >>>>>>>>>>> caller then it isn't a halt decider.
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> The first H(P,P) that is invoked always returns a value to
> >>>>>>>>>> its caller. Subsequent recursive invocations are a part of
> >>>>>>>>>> infinitely nested simulation that must be aborted.
> >>>>>>>>>
> >>>>>>>>> Nope. A pure function always returns the same value for the
> >>>>>>>>> same inputs:
> >>>>>>>>
> >>>>>>>> One can assume this when one has never bothered to think
> >>>>>>>> infinitely nested simulation all the way through. Parroting
> >>>>>>>> things that textbooks say is of no use because textbooks have
> >>>>>>>> never addressed this.
> >>>>>>>>
> >>>>>>>> The idea of a simulating halt decider that correctly detects
> >>>>>>>> infinitely nested simulation of the conventional halting
> >>>>>>>> problem proof counter-examples is brand new with me so you
> >>>>>>>> won't find any textbook that discusses it.
> >>>>>>>>
> >>>>>>>> The outer-most H(P,P) is a pure function of its inputs.
> >>>>>>>
> >>>>>>> Then the H that P calls is a different H because as I just
> >>>>>>> stated, "a pure function always returns the same value for the
> >>>>>>> same inputs".
> >>>>>>>
> >>>>>>> You can't just redefine accepted computer science concepts
> >>>>>>> such as what constitutes a pure function.
> >>>>>>>
> >>>>>>
> >>>>>> It is the case that the outer H(P,P) is a pure function of its
> >>>>>> inputs.
> >>>>>
> >>>>> So your tactic now is simply to ignore what people say and just
> >>>>> repeat yourself? What is the point of doing that? Seems like a
> >>>>> waste of time to me.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> We need actual PhD computer scientists that are experts in the
> >>>> theory of computation to evaluate these things. You guys are
> >>>> merely spouting off misonceptions.
> >>>
> >>> LOL. Appeal to authority, a logical fallacy, mate.
> >>>
> >>> /Flibble
> >>>
> >>
> >> People that only understand these things from the very shallow
> >> perspective of learned-by-rote can't see any of the relevant
> >> details.
> >>
> >> The best that they can do is parrot the words of others never
> >> realizing that these words do not apply to this case. No one has
> >> ever examined this case before.
> >
> > More repetition and refusal to engage in reasoned debate. You've got
> > nothing.
> >
> > /Flibble
> >
>
> You are spouting off things that are not true and too ignorant to
> understand that they are not true.
You have not addressed my argument: simply asserting that my argument
is false without explaining why just doesn't cut the mustard I'm afraid.

You've got no argument. You've got nothing.

/Flibble

On 6/11/22 11:11 AM, olcott wrote:
> On 6/11/2022 10:01 AM, Mr Flibble wrote:
>> On Sat, 11 Jun 2022 09:59:10 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> On 6/11/2022 9:55 AM, Mr Flibble wrote:
>>>> On Sat, 11 Jun 2022 09:52:34 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>> On 6/11/2022 9:40 AM, Mr Flibble wrote:
>>>>>> On Sat, 11 Jun 2022 09:35:02 -0500
>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>> On 6/11/2022 7:03 AM, Mr Flibble wrote:
>>>>>>>> On Sat, 11 Jun 2022 00:03:37 -0500
>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>
>>>>>>>> "H(P,P) as a pure function of its inputs is easy"
>>>>>>>>
>>>>>>>> If H as a "pure function" doesn't return a result to its caller
>>>>>>>> then it isn't a halt decider.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>
>>>>>>> The first H(P,P) that is invoked always returns a value to its
>>>>>>> caller. Subsequent recursive invocations are a part of infinitely
>>>>>>> nested simulation that must be aborted.
>>>>>> Nope. A pure function always returns the same value for the same
>>>>>> inputs:
>>>>>
>>>>> One can assume this when one has never bothered to think infinitely
>>>>> nested simulation all the way through. Parroting things that
>>>>> textbooks say is of no use because textbooks have never addressed
>>>>> this.
>>>>>
>>>>> The idea of a simulating halt decider that correctly detects
>>>>> infinitely nested simulation of the conventional halting problem
>>>>> proof counter-examples is brand new with me so you won't find any
>>>>> textbook that discusses it.
>>>>>
>>>>> The outer-most H(P,P) is a pure function of its inputs.
>>>>
>>>> Then the H that P calls is a different H because as I just stated,
>>>> "a pure function always returns the same value for the same inputs".
>>>>
>>>> You can't just redefine accepted computer science concepts such as
>>>> what constitutes a pure function.
>>>
>>> It is the case that the outer H(P,P) is a pure function of its inputs.
>>
>> So your tactic now is simply to ignore what people say and just repeat
>> yourself? What is the point of doing that? Seems like a waste of time
>> to me.
>>
>> /Flibble
>>
>
> We need actual PhD computer scientists that are experts in the theory of
> computation to evaluate these things. You guys are merely spouting off
> misonceptions.
>

Well, then I guess you are admitting you don't understand it too, as you
aren't one of those either.

The key point is it DOESN'T take someone with a degree to see what is
true here, a Freshman (or maybe even younger) with basic training can
see the flaws in your logic.

Note, logic isn't like Physics or the like where the first rules that
are learned are only approximations of the truth, but the true
fundamentals ARE the fundamentals that always hold.

When we get to Computation Theory, we start with the definition of a
Algorithm, being the definite finite list of deterministic steps to
perform on the data (and only the provided data, and what is computed
from it), and define a Computation as the applying of a specific
Algorithm to a specific set of Data, we can show as a first proof that a
given algorithm applied to a given input data, will always produce the
same results.

This becomes later a basis of the definition of a Pure Function.

Turing Machines, by their design, embody an algorithm and accept their
data on the tape.

This means your H, which you claim to act differently based on where it
is called from, CAN'T actully be the embodyment of a pure algorithm
acting only on the data provided, but MUST have some other input to it,
dispite what you claim.

I have in the past asked you some simpe questions, that if you actually
tried to answer, would have shown you where you were wrong, or provided
you with a basis to make yourself famouse (or infamous) by disproving
this fundamental property of Algorithms (perhaps putting you above
Russell with his disproving the consistency of Naive Set Theory). Just
look at the ACTUAL execution trace of the two instances of H(P,P), that
directly called from main, and that called by P(P), and find the first
instruction where there behavior differs.

If this difference is caused by it peeking at something that wasn't part
of the defined input (or derived from it) then you have just shown to
yourself that you H wasn't actually a pure function, as it used
something besides its input to determine its behavior.

If this difference is based on just processing the input, you need to
figure out how an specific exact x86 instruction, given the exact same
input in the two cases (since this is the FIRST point of divergence, and
the input is the same between the two traces, and it is only using the
input, nothing can be different yet) yielded different results for the
two paths.

The fact that even the most junior computer scientist would tell you
that if a computer instruction when executed with the same inputs gives
different output shows a broken computer (unless the instruction
specifically is defined to generate random numbers or access things
"outside"), should show you that you must be wrong about H being written
as a pure function and showing this behavior.

I think you have been working very hard at trying to come up with ways
to HIDE the outside input to your algorithm (perhaps even trying to hide
it from yourself) and that is why it has taken you the decades to write
it. (Deception can be hard to pull off well).

Your repeated claims just show either your ignorance of the basic rules
of logic and compuations (and a fundamentel inability to understand
them), or that you are just a pathological liar, or that you are both.

On 6/11/22 11:29 AM, olcott wrote:

> You are spouting off things that are not true and too ignorant to
> understand that they are not true.
>

No, YOU are the one spouting off things that are not ture and are too
ignorant to undered that they are not true.

You can't even correctly define the basic terms and show how they
actually apply.

When people state the fundamental rules, you dismiss them as parroting
book learning.

Well, it is a fact that book learning is much better than ignorance from
never learning, which seems to be where you are coming from.

If you refuse to let the fundamental rules apply, then you are just
admitting that you aren't working in the field.

The fact that you don't let even the fundamental rules of logic apply,
means you are not even talking about things of logic and truth, ie. you
are just discussing your own fantasies about things with no actual basis.

YOU ARE JUST LIVING IN YOUR OWN LIES.

On 6/11/22 11:14 AM, olcott wrote:
> On 6/11/2022 10:02 AM, Richard Damon wrote:
>> On 6/11/22 10:52 AM, olcott wrote:
>>> On 6/11/2022 9:40 AM, Mr Flibble wrote:
>>>> On Sat, 11 Jun 2022 09:35:02 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>
>>>>> On 6/11/2022 7:03 AM, Mr Flibble wrote:
>>>>>> On Sat, 11 Jun 2022 00:03:37 -0500
>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>
>>>>>> "H(P,P) as a pure function of its inputs is easy"
>>>>>>
>>>>>> If H as a "pure function" doesn't return a result to its caller
>>>>>> then it isn't a halt decider.
>>>>>>
>>>>>> /Flibble
>>>>>>
>>>>>
>>>>> The first H(P,P) that is invoked always returns a value to its caller.
>>>>> Subsequent recursive invocations are a part of infinitely nested
>>>>> simulation that must be aborted.
>>>> Nope. A pure function always returns the same value for the same
>>>> inputs:
>>>>
>>>
>>> One can assume this when one has never bothered to think infinitely
>>> nested simulation all the way through. Parroting things that
>>> textbooks say is of no use because textbooks have never addressed this.
>>>
>>> The idea of a simulating halt decider that correctly detects
>>> infinitely nested simulation of the conventional halting problem
>>> proof counter-examples is brand new with me so you won't find any
>>> textbook that discusses it.
>>>
>>> The outer-most H(P,P) is a pure function of its inputs.
>>
>> But not ALL H(P,P)? Then it isn't a pure function at all, an y ou are
>> just shoing that you don;t understand what you are talking about.
>
>
> We need actual PhD computer scientists that are experts in the theory of
> computation to evaluate these things. You guys are merely spouting off
> misconceptions.
>
> No theory of computation PhD computer scientist has ever analyzed the
> concept of a simulating halt decider being applied to the HP
> counter-example inputs ALL THE WAY THROUGH.
>
>

Nope, you need to realize that basic definitions apply.

Your arguements are based on false definitions and thus are just invalid.

You are just proving your own stupidity.

You H is proved not to be a pure function, by your own description of
its behavior, and thus it can not be a decider, because it can't be an
actual computation.

YOU FAIL.

On 6/11/22 11:19 AM, olcott wrote:
> On 6/11/2022 10:17 AM, Richard Damon wrote:
>> On 6/11/22 10:57 AM, olcott wrote:
>>> On 6/11/2022 9:52 AM, Richard Damon wrote:
>>>>
>>>> On 6/11/22 10:35 AM, olcott wrote:
>>>>> On 6/11/2022 7:03 AM, Mr Flibble wrote:
>>>>>> On Sat, 11 Jun 2022 00:03:37 -0500
>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>
>>>>>> "H(P,P) as a pure function of its inputs is easy"
>>>>>>
>>>>>> If H as a "pure function" doesn't return a result to its caller
>>>>>> then it
>>>>>> isn't a halt decider.
>>>>>>
>>>>>> /Flibble
>>>>>>
>>>>>
>>>>> The first H(P,P) that is invoked always returns a value to its caller.
>>>>> Subsequent recursive invocations are a part of infinitely nested
>>>>> simulation that must be aborted.
>>>>>
>>>>
>>>> Then it isn't a Computation based on an actual finite definite
>>>> deterministic algrorithm based solely on its inputs.
>>>>
>>>> Also, it isn't a pure function, as a pure function is DEFINED as a
>>>> function whose behavior is only determined by its inputs, and which
>>>> has no observable side effect.
>>>>
>>>> If main calling H(P,P) gets back a 0, while main calling P calling
>>>> H(P,P) gets infinite recursion, H has just proved itself to NOT be a
>>>> PURE RUNCITON, as its behavior just changed based on something
>>>> besides it's inputs (that would be the two pointers P).
>>>>
>>>> Care to explain HOW H is a pure function when it doesn't meet the
>>>> definition?
>>>>
>>>
>>> No one ever bothered to think through the idea that a simulating halt
>>> decider would detect infinitely nested simulation of its HP inputs
>>> all the way through ever before.
>>>
>>
>> So, no answer.
>>
>> It doesn't matter if anyone thought about this particular case if the
>> were able to disprove it in the general case.
>
> When this case correctly refutes the general case then the general case
> has been refuted.
>

But it doesn't, since you have just admitted that you H doesn't qualify
as a computation, since H(P,P) isn't the same in all cases, so the
algorithm in H MUST take in some other input, and is thus NOT a correct
decider, and not the equivalent of a Turing Machine as needed.

FAIL.

You are just too dumb to understand that you are wrong.

On 6/11/2022 10:31 AM, Mr Flibble wrote:
> On Sat, 11 Jun 2022 10:29:06 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/11/2022 10:19 AM, Mr Flibble wrote:
>>> On Sat, 11 Jun 2022 10:18:14 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/11/2022 10:12 AM, Mr Flibble wrote:
>>>>> On Sat, 11 Jun 2022 10:11:37 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/11/2022 10:01 AM, Mr Flibble wrote:
>>>>>>> On Sat, 11 Jun 2022 09:59:10 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/11/2022 9:55 AM, Mr Flibble wrote:
>>>>>>>>> On Sat, 11 Jun 2022 09:52:34 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 6/11/2022 9:40 AM, Mr Flibble wrote:
>>>>>>>>>>> On Sat, 11 Jun 2022 09:35:02 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 6/11/2022 7:03 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On Sat, 11 Jun 2022 00:03:37 -0500
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> "H(P,P) as a pure function of its inputs is easy"
>>>>>>>>>>>>>
>>>>>>>>>>>>> If H as a "pure function" doesn't return a result to its
>>>>>>>>>>>>> caller then it isn't a halt decider.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The first H(P,P) that is invoked always returns a value to
>>>>>>>>>>>> its caller. Subsequent recursive invocations are a part of
>>>>>>>>>>>> infinitely nested simulation that must be aborted.
>>>>>>>>>>>
>>>>>>>>>>> Nope. A pure function always returns the same value for the
>>>>>>>>>>> same inputs:
>>>>>>>>>>
>>>>>>>>>> One can assume this when one has never bothered to think
>>>>>>>>>> infinitely nested simulation all the way through. Parroting
>>>>>>>>>> things that textbooks say is of no use because textbooks have
>>>>>>>>>> never addressed this.
>>>>>>>>>>
>>>>>>>>>> The idea of a simulating halt decider that correctly detects
>>>>>>>>>> infinitely nested simulation of the conventional halting
>>>>>>>>>> problem proof counter-examples is brand new with me so you
>>>>>>>>>> won't find any textbook that discusses it.
>>>>>>>>>>
>>>>>>>>>> The outer-most H(P,P) is a pure function of its inputs.
>>>>>>>>>
>>>>>>>>> Then the H that P calls is a different H because as I just
>>>>>>>>> stated, "a pure function always returns the same value for the
>>>>>>>>> same inputs".
>>>>>>>>>
>>>>>>>>> You can't just redefine accepted computer science concepts
>>>>>>>>> such as what constitutes a pure function.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It is the case that the outer H(P,P) is a pure function of its
>>>>>>>> inputs.
>>>>>>>
>>>>>>> So your tactic now is simply to ignore what people say and just
>>>>>>> repeat yourself? What is the point of doing that? Seems like a
>>>>>>> waste of time to me.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> We need actual PhD computer scientists that are experts in the
>>>>>> theory of computation to evaluate these things. You guys are
>>>>>> merely spouting off misonceptions.
>>>>>
>>>>> LOL. Appeal to authority, a logical fallacy, mate.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> People that only understand these things from the very shallow
>>>> perspective of learned-by-rote can't see any of the relevant
>>>> details.
>>>>
>>>> The best that they can do is parrot the words of others never
>>>> realizing that these words do not apply to this case. No one has
>>>> ever examined this case before.
>>>
>>> More repetition and refusal to engage in reasoned debate. You've got
>>> nothing.
>>>
>>> /Flibble
>>>
>>
>> You are spouting off things that are not true and too ignorant to
>> understand that they are not true.
>
> You have not addressed my argument: simply asserting that my argument
> is false without explaining why just doesn't cut the mustard I'm afraid.
>
> You've got no argument. You've got nothing.
>
> /Flibble
>

The execution traces prove that I am correct that you simply "do not
believe in" these execution traces is no rebuttal at all.

--
Copyright 2022 Pete Olcott

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