Symbolic Differentiation

Ask a computer algebra system for the derivative of $x^3 \sin(x)$ and it answers instantly with $3x^2\sin(x) + x^3\cos(x)$ — not a decimal approximation near some point, but the exact formula, valid everywhere. How?

The trick is to stop thinking of a formula as text and start thinking of it as a tree. The expression $x^3 \sin(x)$ is really a multiplication node with two children: a power node ($x^3$) and a sine node ($\sin(x)$). Every formula, no matter how nested, decomposes this way down to leaves that are just variables and constants.

Once you have a tree, differentiation stops being an art. It becomes a handful of mechanical rewriting rules — one for addition, one for multiplication, one for composition — applied recursively from the root down to the leaves. No calculus insight is needed at the moment of computing; all the insight was baked into the rules centuries ago by Newton, Leibniz and their successors. The machine just follows them, perfectly, every time.

Pick one of the sample functions below and press Differentiate to watch the algorithm walk the expression tree and rewrite each node using the matching rule.

<p class="hint">{{hint_para}}</p>
<div class="row">
  <label for="fnSelect" class="sr-only">{{choose_label}}</label>
  <select id="fnSelect"></select>
  <button id="diff" type="button">{{btn_diff}}</button>
  <button id="reset" type="button" class="ghost">{{btn_clear}}</button>
</div>
<div class="panels">
  <div class="panel">
    <div class="panel-title">{{panel_original}}</div>
    <div id="original" class="expr"></div>
  </div>
  <div class="panel">
    <div class="panel-title">{{panel_derivative}}</div>
    <div id="derivative" class="expr placeholder">{{derivative_placeholder}}</div>
  </div>
</div>
<div class="panel-title">{{panel_log}}</div>
<div id="log" class="log"></div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; }
.hint { font-size: .9rem; color: #444; margin: 0 0 .7rem; line-height: 1.45; }
.sr-only { position: absolute; width: 1px; height: 1px; overflow: hidden; clip: rect(0 0 0 0); }
.row { display: flex; gap: .5rem; flex-wrap: wrap; align-items: center; margin-bottom: .7rem; }
select { font: 600 14px system-ui, sans-serif; padding: .4rem .6rem; border-radius: 8px; border: 1px solid #adb1b8; }
button { font: 600 14px system-ui, sans-serif; padding: .45rem .9rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
.panels { display: grid; grid-template-columns: 1fr 1fr; gap: .6rem; margin-bottom: .7rem; }
@media (max-width: 520px) { .panels { grid-template-columns: 1fr; } }
.panel-title { font-size: .78rem; font-weight: 700; text-transform: uppercase; letter-spacing: .04em;
               color: #6b7280; margin: 0 0 .3rem; }
.expr { font: 700 18px ui-monospace, monospace; background: #e8eef3; border: 1px solid #cdd9e3;
        border-radius: 8px; padding: .7rem .8rem; min-height: 1.6em; color: #1d3557; word-break: break-word; }
.expr.placeholder { color: #8a97a6; font-weight: 500; font-family: system-ui, sans-serif; font-size: .9rem; }
.log { font: 13px ui-monospace, monospace; background: #16223a; color: #d7e2f0; border-radius: 8px;
       padding: .6rem .7rem; min-height: 2.4em; max-height: 220px; overflow-y: auto; line-height: 1.55; }
.log .step { color: #8fd3a3; }
.log .rule { color: #ffd166; }

// Code not found

The log panel shows every rule firing in order: a product becomes $u'v + uv'$, a quotient becomes $\frac{u'v - uv'}{v^2}$, and a composition $f(g(x))$ becomes $f'(g(x)) \cdot g'(x)$ — the chain rule. Nothing is evaluated at a numeric point; the output is a brand-new tree that represents the derivative as a formula for every $x$ at once.

Differentiating one node is $O(1)$ work: look up which rule applies (sum, product, quotient, power, chain) and build the corresponding new nodes from the derivatives of the children. Since every node is visited exactly once, differentiating a tree with $n$ nodes takes $O(n)$ time — differentiation itself is cheap, always, no matter how deep the nesting.

The catch is what comes out the other end. Each rule can more than double the size of a subtree: the product rule alone turns one node into a sum of two products, and if that pattern repeats at every level of a deeply nested expression, the un-simplified derivative can grow exponentially in the depth of the original formula. This is the well-known expression swell problem — the rules are simple, but naively applying them over and over produces monstrously large formulas full of redundant subexpressions.

In practice every computer algebra system fights this with simplification and common-subexpression sharing: rewriting $x + 0 \to x$, $1 \cdot y \to y$, merging identical subtrees, and sometimes representing the expression as a directed acyclic graph instead of a tree so repeated pieces are stored once. Differentiation is the easy half of the job; taming the resulting formula so it stays human-readable — and so a later evaluation of it is fast — is the half that takes engineering. This is also why heavy numerical pipelines like neural network training prefer automatic differentiation: it accumulates derivative values through the same chain rule without ever materializing the blown-up symbolic formula.

Whenever the formula itself is the deliverable — not just a number at a point — symbolic differentiation is the tool of choice:

• Computer algebra systems: Mathematica, Maple, SymPy and Wolfram|Alpha all use expression-tree differentiation to solve calculus problems the same way a textbook would show its work.
• Exact physics and engineering derivations: deriving equations of motion, Jacobians of robot kinematics, or sensitivity formulas in control theory often needs a closed-form expression, not just its value at one configuration.
• Symbolic optimization and simplification: some solvers manipulate the derivative formula further (setting it to zero, factoring it) — something only possible if it exists as a real expression, not a black-box gradient evaluator.
• Teaching and verification: symbolic differentiation is the natural way to check that a hand-derived formula or a numerical gradient approximation is actually correct.

Anywhere a human eventually needs to read the derivative — a textbook, a paper, a control law — this tree-rewriting approach is doing the work behind the scenes.

Symbolic differentiation turns one of the first hard things you learn in calculus into a small, mechanical, always-correct recursion: look at the root of the tree, apply the matching rule, recurse into the children. There is no approximation and no guesswork — just Newton and Leibniz's rules, executed with perfect discipline.

The cost of that perfection is size: applied naively, the exact answer can balloon far faster than the question that produced it. Every real computer algebra system is, underneath, this same tree-rewriting idea plus a constant fight against its own output — a reminder that being exact and being efficient are not always the same problem, a tension that also shapes how P vs NP separates easy answers from easy-to-check ones.