I was (pleasantly) surprised that when a Derivative is taken of a symbolic function for which the last few arguments are Rules, a Derivative object is returned with just the right number of arguments to ignore the Rules:

D[f[x,y,a->b],x] // InputForm
(*  Derivative[0,1][f][x,y,a->b]  *)

(*  NOT:  Derivative[0,1,0][f][x,y,a->b] *)

This makes sense since the Rules could represents options to the function f.

Question: Has this behavior of D and Derivative been with Mathematica since v1?

But, then there is a strange behavior when D is taken of a function in which a Rule appears in a middle argument:

(*  (0 -> 0) Derivative[0, 1, 0][f][x, a -> b, y] + Derivative[1, 0, 0][f][x, a -> b, y] *)

(*  Derivative[0, 0, 1][f][x, a -> b, y] + (0 -> 0)*Derivative[0, 1, 0][f][x, a -> b, y] *)

Question: what is the interpretation of this output? In particular, what is the meaning of the term proportional to 0 -> 0?

  • 2
    $\begingroup$ It looks like D threads over Rule: e.g. D[x -> x, x] evaluates to 1 -> 1. So it looks like the behavior you're seeing is a chain rule: for some reason D sees the Rule as a function of x, and so applies the chain rule. The D then threads over a -> b, yielding 0 -> 0 since a and b are independent of x. $\endgroup$
    – march
    Dec 29, 2015 at 17:00
  • $\begingroup$ @march I would report that, don't you think? $\endgroup$
    – Kuba
    Feb 16, 2016 at 13:39
  • $\begingroup$ @Kuba I forgot about this! I will do this later today. $\endgroup$
    – march
    Feb 16, 2016 at 15:07

1 Answer 1


First of all, D Threads over Rule:

D[x -> x, x]
(* 1 -> 1 *)

Thus, the behavior you're seeing is just the chain rule. D sees f[x, Rule[a, b], y] as a function of three inputs, and so takes the derivative of the outside function multiplied by the inside functions:

D[f[x, a -> b, y], x]
(* (0 -> 0) Derivative[0, 1, 0][f][x, a -> b, y] + Derivative[1, 0, 0][f][x, a -> b, y] *)

Interestingly, there's something special about the way that D treats functions with Rules as arguments. Aside from the observation made in the OP (that D sees f[x, a -> b] as a function of one argument x, with the second argument understood to be Options for f), there is also the following. Even if I try to UpSet automatic Threading for D of some undefined symbol g,

g /: D[g[a_, b_], x_] := g[D[a, x], D[b, x]]
SetAttributes[g, SequenceHold]  (* to mimic the `Attributes` of `Rule` *)

the behavior noted in the OP doesn't occur:

D[f[x, g[a, b], y], x]
(* Derivative[1, 0, 0][f][x, a -> b, y] *)

which means that D looks at the structure of the expression as a whole first and decides what arguments are functions of x and which are not before applying derivatives to those arguments according to the chain rule. Of course, it does this unless one of the arguments is a Rule, in which case it does take the derivative of the argument (or it Threads over it, depending on where it is in the expression).

This is not a complete answer, since I don't know why (and exactly how) D treats Rules as arguments separately. Nonetheless, the OP is seeing a chain rule, so that's the explanation for the behavior in the OP.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.