Free lesson · Differential calculus

Chain rule workshop: nested functions and backpropagation

Open interactive lessonPractice calculationsExplore labs

Start here · the same idea in everyday words

Unpack a technical sentence

Technical wording: Reverse accumulation propagates sensitivities through a scalar composition.

Read it as: Work backward through a chain of calculations. At each step, multiply by how quickly that step’s output changes. A scalar is just one number rather than a list of numbers.

A slower worked example · one step at a time

1. Start with x=1. The first calculation doubles x and adds one, giving u=3. The second calculation squares u, giving an output of 9. All values in this example are dimensionless.
2. The first calculation has slope 2: increasing x by .01 increases u by .02.
3. At u=3, the squaring calculation has slope 6. Combine the slopes: 6 times 2 gives 12 output units per input unit.
4. A small input increase of .01 therefore predicts an output increase of 12 times .01, or .12. The actual output at x=1.01 is 3.02 squared, or 9.1204.
5. The prediction gives 9.12 rather than 9.1204 because a derivative describes a tiny change. The remaining .0004 comes from curvature. In the larger loss example below, there is one more step: translate the model output’s change into the loss change.

Study loop: predict the result, work through the arithmetic, run the Python, then explain which assumption would make the result unreliable.

• Name every intermediate value before differentiating: x feeds u, u feeds v, and v feeds a loss L. Work forward to get values, then backward to propagate sensitivities.
• For a scalar chain, reverse accumulation starts at the loss with sensitivity one. At a branching node, contributions add because the total differential is linear. This is the calculus behind backpropagation and reverse-mode automatic differentiation.
• Here x, u, v and L are dimensionless synthetic calibration quantities. Automatic differentiation applies exact chain rules to the implemented operations, subject to floating-point arithmetic; finite differences approximate a derivative by evaluating nearby inputs. Neither method checks whether the economic model is correct.

An analogy to remember

A gear train multiplies rotation ratios along each connected path. A branching drive adds the contributions that reach the same output.

How this becomes a building block

A calibration routine can return both its loss and gradient. Passing the gradient to an optimiser saves repeated model evaluations, but the step size still needs its own control.

Python · run and reuse

Architecture pseudocode

# Python 3.10+; standard library only unless NumPy is imported.
# Synthetic teaching inputs; no historical performance claim.
def loss_and_gradient(x, target):
    # All inputs/outputs dimensionless; target held fixed.
    u = 3*x*x + 1
    v = u**4
    residual = v-target
    return 0.5*residual**2, residual*4*u**3*6*x

def check_gradient(x, target, h=1e-6):
    if h <= 0: raise ValueError("h must be positive")
    return (loss_and_gradient(x+h,target)[0]-loss_and_gradient(x-h,target)[0])/(2*h)

print(loss_and_gradient(1,250), check_gradient(1,250))

# Replay the slower, synthetic example above. Units are stated in its steps.
def plain_language_example():
    from math import exp, e  # Standard library; no extra dependency.
    return {
        "start": (2*1+1)**2,
        "slope": 2*(2*1+1)*2,
        "prediction": 9+12*.01,
        "actual": (2*1.01+1)**2,
    }

print(plain_language_example())

Research checkpoint · reviewed 13 October 2026

Noguer I Alonso, Derivative-Informed Operator Learning for Finance, arXiv working paper submitted 4 June 2026. Abstract-only review: reported model experiments use Black–Scholes, Heston and Bates derivatives; historical market instruments and observation dates are not established by the abstract. It motivates checking sensitivities separately from prices. We adopt no reported error reduction as a trading result; derivative consistency does not by itself ensure economic constraints or profitable hedging.

Further reading: Primary working paper · arXiv:2606.05900 ↗

# Python 3.10+; standard library only unless NumPy is imported.
# Synthetic teaching inputs; no historical performance claim.
def loss_and_gradient(x, target):
    # All inputs/outputs dimensionless; target held fixed.
    u = 3*x*x + 1
    v = u**4
    residual = v-target
    return 0.5*residual**2, residual*4*u**3*6*x

def check_gradient(x, target, h=1e-6):
    if h <= 0: raise ValueError("h must be positive")
    return (loss_and_gradient(x+h,target)[0]-loss_and_gradient(x-h,target)[0])/(2*h)

print(loss_and_gradient(1,250), check_gradient(1,250))

# Replay the slower, synthetic example above. Units are stated in its steps.
def plain_language_example():
    from math import exp, e  # Standard library; no extra dependency.
    return {
        "start": (2*1+1)**2,
        "slope": 2*(2*1+1)*2,
        "prediction": 9+12*.01,
        "actual": (2*1.01+1)**2,
    }

print(plain_language_example())