Applying rules with functions to expressions with derivatives

Question

I have a function that I want to see applied, potentially within a derivative. The use of delayed vs. non-delayed rules seems irrelevant. See the following:

f$sub = {f[c_] :> a c};

f[c] //. f$sub;

q (f[c])^2 //. f$sub;

D[f[c], c] //. f$sub;

D[f[c] //. f$sub, c] //. f$sub;

(*The following is a rough reason of why I wanted rules *)
g$sub = {g[a] :> a + f[c] }

g2$sub = {g2[a] :> a + D[f[c], c] }

g[a] //. g$sub (* Don't want f sub'd, want to see it left with the function *)

g[a] //. Union[g$sub, f$sub] (* Want f$sub used to simplify things *)

f$alt$sub = {f[c_] :> 2 a c};

g2[a] //. Union[g2$sub, f$alt$sub ](* What does it look like with the alternative *)

Ideally, I would want to see the output as a c, q (a c)^2, a. The last doesn't work, presumably becomes FullForm@D[f[c],c] is Derivative[1][f][c] which doesn't match the pattern. Are there any easy tricks to get the substitution to respect derivatives? My first attempt of changing the rule to fsub = {f[c_] :> a c, Derivative[1][f][c_] :> D[f[c], c]} didn't seem to do anything (delayed or not).

Answer 1

Here's another possibility:

Clear[f,g,a,c]

f$sub = {f :> Function[{c}, a c]};

f[c] //. f$sub

(* ==> a c *)

q (f[c])^2 //. f$sub

(* ==> a^2 c^2 q *)

D[f[c], c] //. f$sub

(* ==> a *)

D[f[c] //. f$sub, c] //. f$sub

(* ==> a *)

g$sub = {g :> Function[a, a + f[c]]};

g2$sub = {g2 :> Function[a, a + D[f[c], c]]};

g[a] //. g$sub (*Don't want f sub'd,want to see it left with the \
function*)

(* ==> a + f[c] *)

g[a] //. 
 Union[g$sub, f$sub] (*Want f$sub used to simplify things*)

(* ==> a + a c *)

The only difference to your substitution rules is that I substitute only the Head and replace it by a Function containing the desired form. This works with Derivative because in the FullForm of an expression such as f'[x] you find the f by itself, and the replacement rule won't match it if that rule involves f[c_] as a pattern.

What happens behind the scenes in your derivative example is that D[...] gets converted into Derivative, which can cause consternation if you make patterns that are intended to match the function in D[f[x],x] because f[x] never appears in that form there.

Answer 2

Blackbird suggested defining a function f rather than using a replacement rule.
Indeed, this appears to work as requested:

fn = Block[{f}, f[c_] := a c; #] &;

f[c]       // fn
q (f[c])^2 // fn
D[f[c], c] // fn

a c

a^2 c^2 q

a