This is my paraphrase of the requirement a partial
halt decider must be a pure function of its inputs:
As long as there is one set of inputs such as such as the formal
parameters to a function and a single output such as return value of
{1,0} (indicating true or false) from this function, then whatever
occurs in-between does not make any difference.
This would mean that my use of static local variables has no detrimental effect on the applicability of my partial halt decider to the halting problem.
u32 H(u32 P, u32 I)
{
 static u32 Aborted;
 static u32* execution_trace;
On 9/18/2021 10:42 PM, olcott wrote:
This is my paraphrase of the requirement a partial
halt decider must be a pure function of its inputs:
As long as there is one set of inputs such as such as the formal parameters to a function and a single output such as return value
of {1,0} (indicating true or false) from this function, then
whatever occurs in-between does not make any difference.
This would mean that my use of static local variables has no
detrimental effect on the applicability of my partial halt decider
to the halting problem.
u32 H(u32 P, u32 I)
{
static u32 Aborted;
static u32* execution_trace;
Although a "pure function" would seem to require both elements on the
link provided below, a "pure function of its inputs" seems to only
require this first element.
(1) The function return values are identical for identical arguments
(no variation with local static variables, non-local variables,
mutable reference arguments or input streams). https://en.wikipedia.org/wiki/Pure_function
This seems to be saying as long as the final return value of a
function is consistently the same for any specific initial arguments
it does not matter that:
(a) local static variables
(b) non-local variables
(c) mutable reference arguments
(d) input streams
are used to achieve this consistent return value.
On Sun, 19 Sep 2021 11:20:15 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/18/2021 10:42 PM, olcott wrote:
This is my paraphrase of the requirement a partial
halt decider must be a pure function of its inputs:
As long as there is one set of inputs such as such as the formal
parameters to a function and a single output such as return value
of {1,0} (indicating true or false) from this function, then
whatever occurs in-between does not make any difference.
This would mean that my use of static local variables has no
detrimental effect on the applicability of my partial halt decider
to the halting problem.
u32 H(u32 P, u32 I)
{
 static u32 Aborted;
 static u32* execution_trace;
Although a "pure function" would seem to require both elements on the
link provided below, a "pure function of its inputs" seems to only
require this first element.
(1) The function return values are identical for identical arguments
(no variation with local static variables, non-local variables,
mutable reference arguments or input streams).
https://en.wikipedia.org/wiki/Pure_function
This seems to be saying as long as the final return value of a
function is consistently the same for any specific initial arguments
it does not matter that:
(a) local static variables
(b) non-local variables
(c) mutable reference arguments
(d) input streams
are used to achieve this consistent return value.
No, a pure function cannot have any side effects: changing static
variables is a side effect.
/Flibble
On 9/19/21 12:20 PM, olcott wrote:
On 9/18/2021 10:42 PM, olcott wrote:
This is my paraphrase of the requirement a partial
halt decider must be a pure function of its inputs:
As long as there is one set of inputs such as such as the formal
parameters to a function and a single output such as return value of
{1,0} (indicating true or false) from this function, then whatever
occurs in-between does not make any difference.
This would mean that my use of static local variables has no
detrimental effect on the applicability of my partial halt decider to
the halting problem.
u32 H(u32 P, u32 I)
{
  static u32 Aborted;
  static u32* execution_trace;
Although a "pure function" would seem to require both elements on the
link provided below, a "pure function of its inputs" seems to only
require this first element.
(1) The function return values are identical for identical arguments
(no variation with local static variables, non-local variables, mutable
reference arguments or input streams).
https://en.wikipedia.org/wiki/Pure_function
This seems to be saying as long as the final return value of a function
is consistently the same for any specific initial arguments it does not
matter that:
(a) local static variables
(b) non-local variables
(c) mutable reference arguments
(d) input streams
are used to achieve this consistent return value.
Right, those items, do not BY THEMSELVES, make the code not a
computation. They do make it much easier for it to end up being not a computation.
Note, The rules for Computaiton theory are different than in 'Normal' Computer Science, which tend to define a Pure Function on a more
mechanical rather than behavioral definition.
Enforcing the mechanical rules makes sure you meet the behavioral rules,
but are not absolutely required.
If you do any of that list, it can be very hard to show that you code
is, in fact, a computation.
On 9/19/2021 1:05 PM, Mr Flibble wrote:
On Sun, 19 Sep 2021 11:20:15 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/18/2021 10:42 PM, olcott wrote:
This is my paraphrase of the requirement a partial
halt decider must be a pure function of its inputs:
As long as there is one set of inputs such as such as the formal
parameters to a function and a single output such as return value
of {1,0} (indicating true or false) from this function, then
whatever occurs in-between does not make any difference.
This would mean that my use of static local variables has no
detrimental effect on the applicability of my partial halt decider
to the halting problem.
u32 H(u32 P, u32 I)
{
static u32 Aborted;
static u32* execution_trace;
Although a "pure function" would seem to require both elements on
the link provided below, a "pure function of its inputs" seems to
only require this first element.
(1) The function return values are identical for identical
arguments (no variation with local static variables, non-local
variables, mutable reference arguments or input streams).
https://en.wikipedia.org/wiki/Pure_function
This seems to be saying as long as the final return value of a
function is consistently the same for any specific initial
arguments it does not matter that:
(a) local static variables
(b) non-local variables
(c) mutable reference arguments
(d) input streams
are used to achieve this consistent return value.
No, a pure function cannot have any side effects: changing static
variables is a side effect.
/Flibble
It does not have to be an actual pure function, it only has to be a
pure function of its inputs.
If it has to be a pure function then it is impossible for any
software function to be able to ever determine that it has been
called in infinite recursion because on each recursive invocation all
of its memory of prior invocations is erased.
On Sun, 19 Sep 2021 13:16:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/19/2021 1:05 PM, Mr Flibble wrote:
On Sun, 19 Sep 2021 11:20:15 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/18/2021 10:42 PM, olcott wrote:
This is my paraphrase of the requirement a partial
halt decider must be a pure function of its inputs:
As long as there is one set of inputs such as such as the formal
parameters to a function and a single output such as return value
of {1,0} (indicating true or false) from this function, then
whatever occurs in-between does not make any difference.
This would mean that my use of static local variables has no
detrimental effect on the applicability of my partial halt decider
to the halting problem.
u32 H(u32 P, u32 I)
{
 static u32 Aborted;
 static u32* execution_trace;
Although a "pure function" would seem to require both elements on
the link provided below, a "pure function of its inputs" seems to
only require this first element.
(1) The function return values are identical for identical
arguments (no variation with local static variables, non-local
variables, mutable reference arguments or input streams).
https://en.wikipedia.org/wiki/Pure_function
This seems to be saying as long as the final return value of a
function is consistently the same for any specific initial
arguments it does not matter that:
(a) local static variables
(b) non-local variables
(c) mutable reference arguments
(d) input streams
are used to achieve this consistent return value.
No, a pure function cannot have any side effects: changing static
variables is a side effect.
/Flibble
It does not have to be an actual pure function, it only has to be a
pure function of its inputs.
"a pure function of its inputs" makes no sense:
a function is either
pure (no side effects at all) or it is impure. Impure functions are
normally called "procedures" rather than functions if we define our
terms taking the intersection of mathematics and computer science as a
guide.
If it has to be a pure function then it is impossible for any
software function to be able to ever determine that it has been
called in infinite recursion because on each recursive invocation all
of its memory of prior invocations is erased.
Then add an extra parameter to the function that is "stack depth" or
some such but note that if we do that then obviously the function is no longer being called with the same arguments as it recurses.
/Flibble
On 9/19/2021 1:29 PM, Mr Flibble wrote:
On Sun, 19 Sep 2021 13:16:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/19/2021 1:05 PM, Mr Flibble wrote:
On Sun, 19 Sep 2021 11:20:15 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/18/2021 10:42 PM, olcott wrote:
This is my paraphrase of the requirement a partial
halt decider must be a pure function of its inputs:
As long as there is one set of inputs such as such as the formal
parameters to a function and a single output such as return
value of {1,0} (indicating true or false) from this function,
then whatever occurs in-between does not make any difference.
This would mean that my use of static local variables has no
detrimental effect on the applicability of my partial halt
decider to the halting problem.
u32 H(u32 P, u32 I)
{
static u32 Aborted;
static u32* execution_trace;
Although a "pure function" would seem to require both elements on
the link provided below, a "pure function of its inputs" seems to
only require this first element.
(1) The function return values are identical for identical
arguments (no variation with local static variables, non-local
variables, mutable reference arguments or input streams).
https://en.wikipedia.org/wiki/Pure_function
This seems to be saying as long as the final return value of a
function is consistently the same for any specific initial
arguments it does not matter that:
(a) local static variables
(b) non-local variables
(c) mutable reference arguments
(d) input streams
are used to achieve this consistent return value.
No, a pure function cannot have any side effects: changing static
variables is a side effect.
/Flibble
It does not have to be an actual pure function, it only has to be a
pure function of its inputs.
"a pure function of its inputs" makes no sense:
It is merely the first element of the linked "pure function"
requirements.
On Sun, 19 Sep 2021 13:40:36 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/19/2021 1:29 PM, Mr Flibble wrote:
On Sun, 19 Sep 2021 13:16:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/19/2021 1:05 PM, Mr Flibble wrote:
On Sun, 19 Sep 2021 11:20:15 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/18/2021 10:42 PM, olcott wrote:
This is my paraphrase of the requirement a partial
halt decider must be a pure function of its inputs:
As long as there is one set of inputs such as such as the formal >>>>>>> parameters to a function and a single output such as return
value of {1,0} (indicating true or false) from this function,
then whatever occurs in-between does not make any difference.
This would mean that my use of static local variables has no
detrimental effect on the applicability of my partial halt
decider to the halting problem.
u32 H(u32 P, u32 I)
{
 static u32 Aborted;
 static u32* execution_trace;
Although a "pure function" would seem to require both elements on
the link provided below, a "pure function of its inputs" seems to
only require this first element.
(1) The function return values are identical for identical
arguments (no variation with local static variables, non-local
variables, mutable reference arguments or input streams).
https://en.wikipedia.org/wiki/Pure_function
This seems to be saying as long as the final return value of a
function is consistently the same for any specific initial
arguments it does not matter that:
(a) local static variables
(b) non-local variables
(c) mutable reference arguments
(d) input streams
are used to achieve this consistent return value.
No, a pure function cannot have any side effects: changing static
variables is a side effect.
/Flibble
It does not have to be an actual pure function, it only has to be a
pure function of its inputs.
"a pure function of its inputs" makes no sense:
It is merely the first element of the linked "pure function"
requirements.
It is merely something that makes no sense. Pure functions CANNOT have
any side effects.
/Flibble
On 9/19/2021 1:44 PM, Mr Flibble wrote:
On Sun, 19 Sep 2021 13:40:36 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/19/2021 1:29 PM, Mr Flibble wrote:
On Sun, 19 Sep 2021 13:16:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/19/2021 1:05 PM, Mr Flibble wrote:
On Sun, 19 Sep 2021 11:20:15 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/18/2021 10:42 PM, olcott wrote:
This is my paraphrase of the requirement a partial
halt decider must be a pure function of its inputs:
As long as there is one set of inputs such as such as the
formal parameters to a function and a single output such as
return value of {1,0} (indicating true or false) from this
function, then whatever occurs in-between does not make any
difference.
This would mean that my use of static local variables has no
detrimental effect on the applicability of my partial halt
decider to the halting problem.
u32 H(u32 P, u32 I)
{
static u32 Aborted;
static u32* execution_trace;
Although a "pure function" would seem to require both elements
on the link provided below, a "pure function of its inputs"
seems to only require this first element.
(1) The function return values are identical for identical
arguments (no variation with local static variables, non-local
variables, mutable reference arguments or input streams).
https://en.wikipedia.org/wiki/Pure_function
This seems to be saying as long as the final return value of a
function is consistently the same for any specific initial
arguments it does not matter that:
(a) local static variables
(b) non-local variables
(c) mutable reference arguments
(d) input streams
are used to achieve this consistent return value.
No, a pure function cannot have any side effects: changing
static variables is a side effect.
/Flibble
It does not have to be an actual pure function, it only has to
be a pure function of its inputs.
"a pure function of its inputs" makes no sense:
It is merely the first element of the linked "pure function"
requirements.
It is merely something that makes no sense. Pure functions CANNOT
have any side effects.
/Flibble
Then a function that can always know when it has been called in
infinite recursion is simply not allowed. That makes no sense.
On Sun, 19 Sep 2021 14:04:41 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/19/2021 1:44 PM, Mr Flibble wrote:
On Sun, 19 Sep 2021 13:40:36 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/19/2021 1:29 PM, Mr Flibble wrote:
On Sun, 19 Sep 2021 13:16:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/19/2021 1:05 PM, Mr Flibble wrote:
On Sun, 19 Sep 2021 11:20:15 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/18/2021 10:42 PM, olcott wrote:
This is my paraphrase of the requirement a partial
halt decider must be a pure function of its inputs:
As long as there is one set of inputs such as such as the
formal parameters to a function and a single output such as
return value of {1,0} (indicating true or false) from this
function, then whatever occurs in-between does not make any
difference.
This would mean that my use of static local variables has no >>>>>>>>> detrimental effect on the applicability of my partial halt
decider to the halting problem.
u32 H(u32 P, u32 I)
{
 static u32 Aborted;
 static u32* execution_trace;
Although a "pure function" would seem to require both elements >>>>>>>> on the link provided below, a "pure function of its inputs"
seems to only require this first element.
(1) The function return values are identical for identical
arguments (no variation with local static variables, non-local >>>>>>>> variables, mutable reference arguments or input streams).
https://en.wikipedia.org/wiki/Pure_function
This seems to be saying as long as the final return value of a >>>>>>>> function is consistently the same for any specific initial
arguments it does not matter that:
(a) local static variables
(b) non-local variables
(c) mutable reference arguments
(d) input streams
are used to achieve this consistent return value.
No, a pure function cannot have any side effects: changing
static variables is a side effect.
/Flibble
It does not have to be an actual pure function, it only has to
be a pure function of its inputs.
"a pure function of its inputs" makes no sense:
It is merely the first element of the linked "pure function"
requirements.
It is merely something that makes no sense. Pure functions CANNOT
have any side effects.
/Flibble
Then a function that can always know when it has been called in
infinite recursion is simply not allowed. That makes no sense.
Your conclusion makes no sense. What isn't allowed here is
your use of the term "pure function" to describe something that isn't a
pure function.
/Flibble
On Sun, 19 Sep 2021 14:27:37 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/19/2021 2:13 PM, Mr Flibble wrote:
On Sun, 19 Sep 2021 14:04:41 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/19/2021 1:44 PM, Mr Flibble wrote:
On Sun, 19 Sep 2021 13:40:36 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/19/2021 1:29 PM, Mr Flibble wrote:
On Sun, 19 Sep 2021 13:16:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/19/2021 1:05 PM, Mr Flibble wrote:
On Sun, 19 Sep 2021 11:20:15 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/18/2021 10:42 PM, olcott wrote:
This is my paraphrase of the requirement a partial
halt decider must be a pure function of its inputs:
As long as there is one set of inputs such as such as the >>>>>>>>>>> formal parameters to a function and a single output such as >>>>>>>>>>> return value of {1,0} (indicating true or false) from this >>>>>>>>>>> function, then whatever occurs in-between does not make any >>>>>>>>>>> difference.
This would mean that my use of static local variables has no >>>>>>>>>>> detrimental effect on the applicability of my partial halt >>>>>>>>>>> decider to the halting problem.
u32 H(u32 P, u32 I)
{
 static u32 Aborted;
 static u32* execution_trace;
Although a "pure function" would seem to require both
elements on the link provided below, a "pure function of its >>>>>>>>>> inputs" seems to only require this first element.
(1) The function return values are identical for identical >>>>>>>>>> arguments (no variation with local static variables,
non-local variables, mutable reference arguments or input
streams). https://en.wikipedia.org/wiki/Pure_function
This seems to be saying as long as the final return value of >>>>>>>>>> a function is consistently the same for any specific initial >>>>>>>>>> arguments it does not matter that:
(a) local static variables
(b) non-local variables
(c) mutable reference arguments
(d) input streams
are used to achieve this consistent return value.
No, a pure function cannot have any side effects: changing
static variables is a side effect.
/Flibble
It does not have to be an actual pure function, it only has to >>>>>>>> be a pure function of its inputs.
"a pure function of its inputs" makes no sense:
It is merely the first element of the linked "pure function"
requirements.
It is merely something that makes no sense. Pure functions CANNOT
have any side effects.
/Flibble
Then a function that can always know when it has been called in
infinite recursion is simply not allowed. That makes no sense.
Your conclusion makes no sense. What isn't allowed here is
your use of the term "pure function" to describe something that
isn't a pure function.
/Flibble
This was always presented to me as "a pure function of its inputs".
So what in your mind is the difference between a pure function and a
"pure function of its inputs"? If a "pure function of its inputs" has
side effects then it isn't a pure function, period.
/Flibble
On 9/19/2021 2:13 PM, Mr Flibble wrote:
On Sun, 19 Sep 2021 14:04:41 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/19/2021 1:44 PM, Mr Flibble wrote:
On Sun, 19 Sep 2021 13:40:36 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/19/2021 1:29 PM, Mr Flibble wrote:
On Sun, 19 Sep 2021 13:16:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/19/2021 1:05 PM, Mr Flibble wrote:
On Sun, 19 Sep 2021 11:20:15 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/18/2021 10:42 PM, olcott wrote:
This is my paraphrase of the requirement a partial
halt decider must be a pure function of its inputs:
As long as there is one set of inputs such as such as the
formal parameters to a function and a single output such as >>>>>>>>> return value of {1,0} (indicating true or false) from this >>>>>>>>> function, then whatever occurs in-between does not make any >>>>>>>>> difference.
This would mean that my use of static local variables has no >>>>>>>>> detrimental effect on the applicability of my partial halt >>>>>>>>> decider to the halting problem.
u32 H(u32 P, u32 I)
{
static u32 Aborted;
static u32* execution_trace;
Although a "pure function" would seem to require both
elements on the link provided below, a "pure function of its >>>>>>>> inputs" seems to only require this first element.
(1) The function return values are identical for identical
arguments (no variation with local static variables,
non-local variables, mutable reference arguments or input
streams). https://en.wikipedia.org/wiki/Pure_function
This seems to be saying as long as the final return value of >>>>>>>> a function is consistently the same for any specific initial >>>>>>>> arguments it does not matter that:
(a) local static variables
(b) non-local variables
(c) mutable reference arguments
(d) input streams
are used to achieve this consistent return value.
No, a pure function cannot have any side effects: changing
static variables is a side effect.
/Flibble
It does not have to be an actual pure function, it only has to
be a pure function of its inputs.
"a pure function of its inputs" makes no sense:
It is merely the first element of the linked "pure function"
requirements.
It is merely something that makes no sense. Pure functions CANNOT
have any side effects.
/Flibble
Then a function that can always know when it has been called in
infinite recursion is simply not allowed. That makes no sense.
Your conclusion makes no sense. What isn't allowed here is
your use of the term "pure function" to describe something that
isn't a pure function.
/Flibble
This was always presented to me as "a pure function of its inputs".
On 9/19/2021 2:29 PM, Mr Flibble wrote:
On Sun, 19 Sep 2021 14:27:37 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/19/2021 2:13 PM, Mr Flibble wrote:
On Sun, 19 Sep 2021 14:04:41 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/19/2021 1:44 PM, Mr Flibble wrote:
On Sun, 19 Sep 2021 13:40:36 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/19/2021 1:29 PM, Mr Flibble wrote:
On Sun, 19 Sep 2021 13:16:24 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/19/2021 1:05 PM, Mr Flibble wrote:
On Sun, 19 Sep 2021 11:20:15 -0500
olcott <NoOne@NoWhere.com> wrote:
On 9/18/2021 10:42 PM, olcott wrote:
This is my paraphrase of the requirement a partial
halt decider must be a pure function of its inputs:
As long as there is one set of inputs such as such as the >>>>>>>>>>> formal parameters to a function and a single output such >>>>>>>>>>> as return value of {1,0} (indicating true or false) from >>>>>>>>>>> this function, then whatever occurs in-between does not >>>>>>>>>>> make any difference.
This would mean that my use of static local variables has >>>>>>>>>>> no detrimental effect on the applicability of my partial >>>>>>>>>>> halt decider to the halting problem.
u32 H(u32 P, u32 I)
{
static u32 Aborted;
static u32* execution_trace;
Although a "pure function" would seem to require both
elements on the link provided below, a "pure function of >>>>>>>>>> its inputs" seems to only require this first element.
(1) The function return values are identical for identical >>>>>>>>>> arguments (no variation with local static variables,
non-local variables, mutable reference arguments or input >>>>>>>>>> streams). https://en.wikipedia.org/wiki/Pure_function
This seems to be saying as long as the final return value >>>>>>>>>> of a function is consistently the same for any specific
initial arguments it does not matter that:
(a) local static variables
(b) non-local variables
(c) mutable reference arguments
(d) input streams
are used to achieve this consistent return value.
No, a pure function cannot have any side effects: changing >>>>>>>>> static variables is a side effect.
/Flibble
It does not have to be an actual pure function, it only has
to be a pure function of its inputs.
"a pure function of its inputs" makes no sense:
It is merely the first element of the linked "pure function"
requirements.
It is merely something that makes no sense. Pure functions
CANNOT have any side effects.
/Flibble
Then a function that can always know when it has been called in
infinite recursion is simply not allowed. That makes no sense.
Your conclusion makes no sense. What isn't allowed here is
your use of the term "pure function" to describe something that
isn't a pure function.
/Flibble
This was always presented to me as "a pure function of its
inputs".
So what in your mind is the difference between a pure function and a
"pure function of its inputs"? If a "pure function of its inputs"
has side effects then it isn't a pure function, period.
/Flibble
Pure functions relate to functional programming in software
engineering. Pure functions of their inputs relates to computer
science computations.
A pure function of its inputs bases its return value entirely on its
inputs and/or additional intermediate computations that are derived
from these inputs.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 296 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 40:35:40 |
| Calls: | 6,648 |
| Files: | 12,193 |
| Messages: | 5,329,420 |