What I'm trying to achieve in Mathematica is the creation of a binary operator whose operands are both pure functions over the natural numbers. The result of the operator should be another pure function over the natural numbers.
To demonstrate concretely what I want, suppose I have the following functions defined:
f[n_Natural]:=2*n;
g[n_Natural]:=n-1;
(There is no Head called "Natural" so the above pattern matching won't work. But I want f and g to accept only natural numbers. This is problem No. 1 [SOLVED])
I then want a binary operator defined like so:
Needs["Notation`"];
CombinedFunction[f_NaturalFunction,g_NaturalFunction]:={#}/.{{x_Natural}:>f[#]+g[#]}}&;
InfixNotation[ParsedBoxWrapper["\[CirclePlus]"], CombinedFunction];
Operating $f$ $\oplus$ $g$ yields a pure function $h$ that only takes a natural number as an argument. I have found a way of enforcing the domain of $h$ thanks to this thread, but I want to extend this to ensure that $\oplus$ itself is only defined for unary functions over the natural numbers. Seeing as there's no Head like 'NaturalFunction', I don't know how to do this. This is problem No. 2.
As an additional issue, the operator (which currently yields a function defined over the integers) currently gives an unsimplified output:
Needs["Notation`"];
CombinedFunction[f_, g_] := {#} /. {{x_Integer} :> f[x] + g[x]} &;
AddInputAlias["4" -> ParsedBoxWrapper["\[CirclePlus]"]];
InfixNotation[ParsedBoxWrapper["\[CirclePlus]"], CombinedFunction];
f=1&;
g=#&;
h=f\[CirclePlus]g
{#1} /. {{x$_Integer} :> (1 &)[x$] \[LeftRightArrow] (#1 &)[x$]} &
I would have expected the output to be:
(1+#)&
I'm unsure of the inner workings of what I've written so I don't know how to obtain a simplified result. I can now apply $h$ to an integer and it operates as expected. However:
h[3.5]
{3.5}
I want instead Mathematica to behave as if the function was simply undefined for anything but an integer, just as it would do if I defined $h$ like so:
Clear[h]; h[x_Integer]:=x+1;
h[3.5]
h[3.5]
f[n_Integer /; Positive[n]] := 2*n; g[n_Integer /; Positive[n]] := n - 1;
(note Natural has a definition where 0 is included, if that's what you need, change condition... $\endgroup$DownValues
- if the functions involved are just your definitions and you use a consistent format for the "naturals" constraint (and /or also wrap any "foreign" function with a definition of your making with the constraint) you can parse the pattern to see if constraint is present. $\endgroup$