“Evaluating” polynomials of functions (Symbols)

Question

I want to implement the following type evaluation symbolically

$$(f^2g + fg + g)(x) \to f(x)^2 g(x) + f(x) g(x) + g(x)$$

In general, on left hand side there is a polynomial in an arbitrary number of functions (e.g. $f, g^3 h, (f_1 + f_2 + f_3)^3, \dots$ and on the right hand side all the functions have been evaluated at the same element $x$. I would to define a function eval or a rule such that

In[1]:= (f^2g + fg + g)[x] // eval
In[2]:= f[x]^2 g[x]+ f[x] g[x] + g[x]

What is a good way of accomplishing this?

Answer 1

polyThrough[h_[a___]] := h /. Map[#1 -> #1[a] &, Variables[h]]
((3 f^2 g + 5 f g + g)^2 )[x, y, z] // polyThrough

((a - b)/(x + y) - 2/z)[] // polyThrough

Answer 2

The first thing that comes to mind is to use Through, as in

Through[(f + g)[x]]

f[x] + g[x]

However, this is a little tricky to apply when you also have powers as in f^2 - so in your case it seems to be more efficient to make use of the fact that all symbols are evaluated at the same x anyway (i.e., there isn't any f[y] and f[z] anywhere). Then you could simply do this:

eval = s_?(MemberQ[{f, g}, #] &) :> s[x]

(* ==> s_?(MemberQ[{f, g}, #1] &) :> s[x] *)

f^2 g + f g + g /. eval

(* ==> g[x] + f[x] g[x] + f[x]^2 g[x] *)

Edit

The above replacement rule eval restricts the names of your functions to f and g, but the list could be expanded arbitrarily. Having an explicit "white list" of names for allowed functions is safer in my opinion. However, one can also construct patterns that don't rely on a knowledge of the function names, as long as we can make some other assumptions.

In response to the comment, let's assume that your polynomial has the added special property that it contains no symbolic constants as coefficients. Then we can be sure that all symbols that aren't arithmetic operations must be functions of x, and therefore, we could test for the property NumericFunction among the Attributes of a symbol:

eval = 
 s_Symbol?(! MemberQ[Attributes[#], NumericFunction] &) :> s[x]

(*
==> s_Symbol?(! MemberQ[Attributes[#1], NumericFunction] &) :> 
 s[x]
*)

f^2 g + f g + g /. eval

(* ==> g[x] + f[x] g[x] + f[x]^2 g[x] *)

This allows you to use any symbol for your functions, as long as it's not a reserved name for a numeric function such as Plus, Times or Power.

Answer 3

The following seems to work pretty well, and not only for polynomials.

Not sure about its robustness.

eval[r_] := r /. u_[s__] :> u /. x_Symbol /; Context@x == "Global`" :> x @@ Level[r, {-1}]

Test drive

(3 f^2 g + f g + g)[u, w] // eval
(*
-> g[u, w] + f[u, w] g[u, w] + 3 f[u, w]^2 g[u, w]
*)


(f^g + d)[w, v] // eval
(*
-> d[w, v] + f[w, v]^g[w, v]
*)


(Sin[h] f + 3 d)[u] // eval
(*
-> 3 d[u] + f[u] Sin[h[u]]
*)

Answer 4

Here is slight modification that generalizes Jens's.

eval[sympoly_, coeffQ_:False] := Head@sympoly /. s_?
    (MemberQ[
       Variables[Head@sympoly] /. v_?coeffQ -> Sequence[]
       , #] &
     ) :> s[Level[sympoly, 1] /. List -> Sequence]

The pattern sympoly_ holds an expression of the form (f^2g + fg + g)[x], as in the question. Jen's evaluation rule is applied to the Head of sympoly, while the evaluation point is extracted using Level and the r.h.s. of Jen's rule s[x] modifed to s[Level[sympoly, 1] /. List -> Sequence].

Which expressions in sympoly are to be considered variables is checked with a Boolean test (MemberQ). First, all possible variables are obtained using Variables. Then, they are filtered with a rule to exclude coefficients (using the ad-hoc test function coeffQ). By default numerical symbols are coefficients as they are not recognized as variables by Variables. The variables of sympoly are the output of

Variables[Head@sympoly] /. v_?coeffQ -> Sequence[]

Here's an example

(3 f^2 g + f g + g)[x] // eval

g[x] + f[x] g[x] + 3 f[x]^2 g[x]

Here coefficients are h[i], h[j], h[k] (any symbol with head h):

eval[(h[i] f^2 g + h[j] f g + h[k] g)[x], Head[#] == h &]

f[x]^2 g[x] h[i] + f[x] g[x] h[j] + g[x] h[k]

The function eval works also on more general symbols

(3 f[1]^2 f[2] + ff g[f[h]])[x, y, z] // eval

3 f[1][x, y, z]^2 f[2][x, y, z] + ff[x, y, z] g[f[h]][x, y, z]