The error that does not travel backwards

“Backpropagating the error” invites a misleading picture. It sounds as if the wrong answer is packaged at the output and carried backwards, layer by layer, until every parameter receives its share of blame. That story is useful for orientation, but it hides the mathematical object doing the work.

The backward quantity is not the error itself. It is the sensitivity of the chosen scalar loss to an intermediate value. At each operation, the system asks: if this input changed by a tiny amount while the rest of the local calculation stayed fixed, how much would the final loss change? The answer is then translated through the next operation, and the next, until it reaches a parameter.

This is why calculus matters. A derivative is a disciplined local comparison. For a scalar function y = f(x), the derivative at x is the limiting ratio between a small output change and the small input change that produced it. It says nothing by itself about large moves, alternative mechanisms, bad labels, missing variables or whether the intervention is physically available.

Make the comparison more explicit. Let a system have two adjustable quantities, θ₁ and θ₂, and let its loss be L(θ₁, θ₂). At one operating point, the gradient might be (4, 1). This does not mean that the first quantity caused four times as much harm. It means that, under the chosen units and while making an infinitesimal move parallel to one coordinate axis, loss changes four times as quickly along θ₁ as along θ₂.

The available action may point elsewhere. If a physical constraint permits only the joint move d = (1, −1), then the relevant first-order change is the directional derivative ∇L · d = 3. If the permitted move is d = (1, −4), the first-order change is zero even though neither coordinate gradient is zero. Credit becomes actionable only after the candidate direction of change is named. A component score without an action model quietly assumes that every coordinate can move independently, by the same unit, at negligible cost.

The watershed picture also exposes a hidden assumption. We often speak as though a component owns a fixed amount of responsibility. In fact, its derivative depends on the current point, the route to the loss and the coordinates used to describe the component. Change any of those, and the number can change even when the forward behaviour does not.

The same boundary applies to the loss. Suppose Trellis is trained against an incorrect label. Backpropagation can be mathematically flawless and still push every parameter in the wrong practical direction. Suppose the loss omits energy use, false-negative cost or a policy constraint. No chain rule will smuggle those concerns into the gradient. It differentiates the objective provided, not the objective intended.

This cancellation is common enough to deserve its own diagnostic. Record the reduction operation, not just the final scalar. A mean over examples, time steps or tasks determines which positive and negative sensitivities meet before the backward pass begins. Per-example gradients can reveal conflict that the aggregate gradient conceals. They still remain local sensitivities, but they expose which parts of the declared objective are supplying them.

flowchart TD
  A["The error that does not travel<br/>backwards"] --> B["One global question, many<br/>local answers"]
  B --> C["When the path changes the credit"]
  C --> D["From sensitivity to a change<br/>you can defend"]
  D -. "re-test" .-> A
  classDef first fill:#0a1424,stroke:#B96D00,stroke-width:2px,color:#e6f3ff
  classDef step fill:#0a1424,stroke:#3f7da0,stroke-width:1px,color:#e6f3ff
  class A first
  class B,C,D step

One global question, many local answers

The chain rule earns its importance by making a distant question decomposable. Begin with a calculation small enough to hold in working memory.

In scalar notation, if z₀ = θ, z₁ = f₁(z₀), and so on until L = zₖ, then the derivative is the product of local derivatives along the chain.

Vectors change the notation, not the idea. Each operation has a Jacobian, a linear map that approximates how a small input displacement changes the output. Reverse mode starts with sensitivity one at the scalar loss and repeatedly applies transposed Jacobians. In automatic-differentiation language, it computes vector-Jacobian products, or pullbacks, from output cotangents to input cotangents (JAX authors).

Read the transpose in that expression as a pullback. Suppose a local operation maps a three-number input into a two-number output. Its Jacobian has two rows and three columns. The backward pass does not need every entry of that matrix as a standalone object. It receives a two-number sensitivity from downstream and multiplies by the transposed Jacobian, producing the three-number sensitivity required upstream. Automatic-differentiation systems call this a vector–Jacobian product or, depending on orientation, a Jacobian-transpose–vector product. The operation answers one targeted question without materialising a potentially enormous Jacobian.

A concrete linear node makes this visible. Let z = Aθ, where θ contains three parameters, z has two outputs and A is a two-by-three matrix. If downstream computation supplies g = ∂L/∂z, then the parameter gradient is Aᵀg. Each column of A tells how one parameter moves both outputs. Multiplication by g weights those movements by what the loss currently cares about. The result is credit for this loss and this downstream state, not a permanent property of the parameter.

This local contract is the source of both efficiency and inspectability. For straight-line arithmetic programs, Baur and Strassen (1983) showed that all first partial derivatives of a scalar result can be obtained with only constant-factor arithmetic overhead relative to evaluating the program. Modern systems complicate the accounting with memory traffic, parallel kernels, control flow and recomputation, but the structural bargain remains: one scalar question can be pulled back to many inputs by reusing local work.

This direction is computationally decisive. A training loss usually has millions or billions of parameter inputs and one scalar output. Forward mode would carry one input perturbation through the graph at a time. Reverse mode shares the forward calculation, then obtains all parameter sensitivities in one reverse traversal. Automatic differentiation is broader than neural-network backpropagation, but backprop is its most visible machine-learning use (Baydin et al., 2018). The efficient reverse accumulation idea also predates its neural-network popularisation (Baur and Strassen, 1983).

Automatic differentiation is therefore neither symbolic differentiation nor finite differencing. Symbolic differentiation rewrites an expression and can expand it into unwieldy formulae. Finite differencing reruns the program after perturbing an input and suffers from truncation and floating-point error. Automatic differentiation executes derivative rules alongside the original primitives, so its result is exact up to ordinary numerical arithmetic for the graph that actually ran. It can still be wrong for the intended system if the graph omits a path, detaches a state, uses an unsuitable surrogate derivative or encodes the wrong objective.

The computational advantage also explains why scalar losses dominate training interfaces. If a system has many outputs and one wants the complete Jacobian with respect to many parameters, no single reverse sweep contains every possible output question. Each seed at the output selects a different linear combination. A scalar loss compresses those questions before differentiation. That compression is a modelling decision: it determines which errors, examples and desiderata become commensurable enough to share one backward signal.

Real computational graphs branch and merge. At a fork, one value influences several descendants. Its total gradient is the sum of the contributions returning through every child. This sum is as important as the pathwise products.

Rumelhart, Hinton and Williams showed how repeated weight adjustments derived this way can make hidden units acquire task-relevant representations (1986). The achievement was not that calculus suddenly discovered hidden layers. It was that a global training error could be translated into local update directions for every weight without separately solving a new optimisation problem for each one.

When the path changes the credit

The chain rule does more than transmit sensitivity. It reshapes it. Products govern a single path, sums govern competing paths, and the graph determines which paths exist. These operations create predictable failure modes.

In recurrent networks, the same parameters are applied over time, so credit to an early state contains a product of many transition Jacobians. Pascanu, Mikolov and Bengio analysed vanishing and exploding gradients through analytical, geometric and dynamical lenses, and proposed gradient clipping for explosion (2013). Clipping controls the size of an update after the fact. It does not reconstruct information already erased by a near-zero product.

The scalar corridor hides a more selective effect. In a vector system, every room applies a Jacobian matrix rather than one gain. A matrix can stretch one direction, shrink another and rotate both. Products of such matrices may preserve the overall norm while erasing the particular direction needed to solve the task. Conversely, a large norm may be concentrated in an irrelevant direction. Monitoring only the average gradient magnitude can therefore miss directional loss of credit.

Singular values provide the local lens. For one Jacobian, a singular value above one amplifies its associated direction and a value below one contracts it. Across depth, the singular directions themselves can rotate, so multiplying average gains is only a rough warning. The exact signal depends on the ordered product encountered along the executed trajectory. This is why initialization, normalisation, gating and architecture alter trainability even when they compute families of similar functions.

Residual connections change that product in a specific way. A plain layer hₖ₊₁ = Fₖ(hₖ) contributes the Jacobian Jₖ. A residual layer hₖ₊₁ = hₖ + Fₖ(hₖ) contributes I + Jₖ, where I is the identity map. The identity term supplies a direct route for both forward state and backward sensitivity. It does not guarantee stable training, but it changes the default from repeatedly replacing a signal to repeatedly perturbing it. The empirical success of residual networks and the analysis of shattered gradients support this path-based explanation within the architectures studied by He and colleagues (2016) and Balduzzi and colleagues (2017).

Feed-forward depth has an additional problem. Even when gradient magnitudes remain controlled, gradients for nearby inputs can become poorly correlated and resemble noise. Balduzzi and colleagues called this gradient shattering and showed that skip connections resist it better than plain deep networks (2017). Residual architectures provide identity routes through which signals and gradients can travel more directly, one reason they made much deeper networks easier to optimise (He et al., 2016).

The reparameterisation example reveals a geometric choice hidden inside ordinary gradient descent. A derivative is a covector: it converts a proposed displacement into a first-order loss change. To turn that covector into an update vector, an optimiser needs a rule for measuring distance in parameter space. Plain gradient descent uses the Euclidean geometry of the current coordinates. Rescale those coordinates and the same function receives a different update.

Methods such as path-normalised optimisation try to remove part of this arbitrariness for positively homogeneous networks. Neyshabur, Salakhutdinov and Srebro (2015) designed Path-SGD so that function-preserving node rescalings do not change its geometry in the same way. This is not a universal solution. Different invariances suit different model classes, and function-space change can still interact with data and loss. The useful lesson is narrower: a ranking becomes stronger when it survives transformations that leave the relevant behaviour unchanged.

This is not a numerical curiosity. If an engineer ranks modules by raw gradient magnitude, equivalent parameterisations can suggest opposite priorities. The gradient is a covector: it transforms when coordinates change. A step direction also depends on the metric used to turn that covector into a parameter displacement. Ordinary gradient descent silently chooses Euclidean geometry in the current coordinates.

The strongest alternative to exact backpropagation is not that credit can be ignored. It is that useful teaching signals may be approximate. Feedback alignment replaces exact transposed forward weights with fixed random feedback pathways, yet can train several linear and nonlinear networks because the forward weights adapt towards useful alignment (Lillicrap et al., 2016). Direct feedback alignment goes further by sending output error directly to hidden layers (Nøkland, 2016).

These results weaken any claim that the exact chain-rule gradient is the only possible learning signal. They do not show that all approximate signals work, that biological brains implement those algorithms, or that gradient correctness is irrelevant. For a fixed smooth graph and scalar objective, reverse mode still computes the precise local derivative. The alternative algorithms change the learning rule and accept a different guarantee.

A finite update asks more than the gradient can answer. For a parameter displacement Δθ, the second-order approximation is ΔL ≈ gᵀΔθ + ½ΔθᵀHΔθ. Here g is the gradient, H is the Hessian and the quadratic term records local curvature along the proposed move. The approximation assumes sufficient smoothness and a displacement small enough for neglected higher-order terms to remain minor. Hessian–vector products can estimate the curvature term without constructing the full matrix, as shown by Pearlmutter (1994).

Curvature improves a step forecast, not the meaning of credit. It can reveal that a large gradient points into a sharply curved wall, or that a modest gradient lies in a broad productive valley. It still inherits the chosen loss, graph, data and coordinates. Second-order optimisation narrows the gradient-to-action gap for local moves; it does not turn optimisation sensitivity into historical causation.

Nonsmooth activations add another boundary. A ReLU has zero derivative throughout its inactive region and no unique classical derivative at zero. Software chooses a convention at the kink. A dead unit can therefore receive no local gradient even when a sufficiently large bias change would reactivate it. Gradient checking near such points must distinguish a coding error from a genuine lack of smoothness.

Gradient-based explanations create a related warning. Input attribution is not the same problem as assigning parameter updates, so the fields should not be equated. Still, implementation invariance and model-randomisation tests show why a visually plausible gradient-derived explanation is not automatically faithful (Sundararajan et al., 2017) (Adebayo et al., 2018). The lesson transfers as a design discipline: test the claimed meaning, rather than only the arithmetic.

stateDiagram-v2
  [*] --> Claim
  state "An autodiff-free<br/>credit-assignment audit" as Claim
  state "Frame the claim" as Test
  state "Test the mechanism" as Revision
  Claim --> Test: expose mechanism
  Test --> Decision: evidence survives
  Test --> Revision: rival survives
  Revision --> Claim: narrow or rebuild
  Decision --> [*]

From sensitivity to a change you can defend

Return to Trellis as a configured system rather than a bare equation. It contains a sensor setting, a clipping preprocessor, a trainable encoder, a calibration layer, a decision threshold and a labelled dataset. Only some of these objects lie inside the differentiable graph. Only some are allowed to change. Only the declared loss contributes a learning signal.

A large encoder gradient may identify a locally effective parameter update. It does not prove that the encoder created the bad label, that changing it is safer than changing exposure, or that the policy threshold should move. A zero sensor gradient may mean saturation, a detached path, cancellation across examples or a genuinely insensitive operating point. The number needs a typed interpretation.

The practical object should therefore be a credit-assignment assay, not a leaderboard of components. Its manifest records the scalar objective, the data slice and reduction, the candidate variable, its units, the executed path, the allowed intervention, the numerical tolerance and the invariances that matter. Without those fields, two teams can report “the gradient” while answering different questions.

The burden should match the decision. A reversible optimiser step may need only a verified derivative and a line-search check. Freezing a module for a month should also test data slices, alternative paths and nearby operating points. Replacing a sensor, changing a policy threshold or blaming a team requires evidence outside the differentiable model. Do not demand every rung for every update, but do not spend higher-stakes authority on lower-rung evidence.

This distinction suggests a ladder rather than a verdict. Each rung permits a stronger decision while retaining the limits of the previous one.

A comparative test of the ladder can be small and decisive. Generate families of two-layer networks that implement the same input-output function through different positive rescalings. Add controlled saturation, redundant paths and mixtures of examples with cancelling gradients. Rank candidate components once by raw gradient magnitude and once by the highest ladder rung passed. Then apply predeclared bounded interventions and measure realised loss change, ranking stability across batches and sensitivity to equivalent parameterisations.

The main prediction is not that higher rungs always produce larger gains. It is that they reduce false confidence: fewer high-ranked components should fail to improve under the permitted intervention, and fewer priorities should reverse under behaviour-preserving re-expression. A null result would be useful. It would show that the additional assay cost does not buy better decisions for that model family, loss and intervention range.

"""Autodiff-free credit-assignment lab for Paper 17.

Uses only Python's standard library. It compares hand-derived gradients with
central finite differences, then exposes saturation, depth and reparameterisation
failure cases.
"""
from __future__ import annotations

from dataclasses import dataclass, replace
import math
from typing import Dict, Tuple


@dataclass(frozen=True)
class Params:
    w1: float = 0.8
    b1: float = -0.1
    w2: float = 1.2
    b2: float = 0.05


def forward(p: Params, x: float, target: float) -> Dict[str, float]:
    """Two-layer scalar network: affine -> tanh -> affine -> squared loss."""
    a = p.w1 * x + p.b1
    h = math.tanh(a)
    y = p.w2 * h + p.b2
    loss = 0.5 * (y - target) ** 2
    return {"a": a, "h": h, "y": y, "loss": loss}


def manual_gradient(p: Params, x: float, target: float) -> Dict[str, float]:
    """Reverse pass written explicitly from local derivatives."""
    cache = forward(p, x, target)
    dloss_dy = cache["y"] - target
    dloss_dw2 = dloss_dy * cache["h"]
    dloss_db2 = dloss_dy
    dloss_dh = dloss_dy * p.w2
    dloss_da = dloss_dh * (1.0 - cache["h"] ** 2)
    dloss_dw1 = dloss_da * x
    dloss_db1 = dloss_da
    return {
        "w1": dloss_dw1,
        "b1": dloss_db1,
        "w2": dloss_dw2,
        "b2": dloss_db2,
    }


def central_difference(
    p: Params, x: float, target: float, name: str, eps: float = 1e-6
) -> float:
    """Black-box local check. It is approximate and sensitive to eps."""
    plus = replace(p, **{name: getattr(p, name) + eps})
    minus = replace(p, **{name: getattr(p, name) - eps})
    return (forward(plus, x, target)["loss"] - forward(minus, x, target)["loss"]) / (
        2.0 * eps
    )


def bounded_effect(
    p: Params, x: float, target: float, name: str, delta: float
) -> Tuple[float, float]:
    """Return actual loss change and first-order predicted loss change."""
    changed = replace(p, **{name: getattr(p, name) + delta})
    actual = forward(changed, x, target)["loss"] - forward(p, x, target)["loss"]
    predicted = manual_gradient(p, x, target)[name] * delta
    return actual, predicted


def sigmoid(z: float) -> float:
    if z >= 0:
        e = math.exp(-z)
        return 1.0 / (1.0 + e)
    e = math.exp(z)
    return e / (1.0 + e)


def saturation_case(z: float = 8.0, target: float = 0.5) -> Dict[str, float]:
    p = sigmoid(z)
    loss = 0.5 * (p - target) ** 2
    local_gradient = (p - target) * p * (1.0 - p)
    reset_p = sigmoid(0.0)
    reset_loss = 0.5 * (reset_p - target) ** 2
    return {
        "probability": p,
        "loss": loss,
        "local_gradient": local_gradient,
        "loss_change_if_reset_to_zero": reset_loss - loss,
    }


def relu_pair(w: float, v: float, x: float, target: float) -> Dict[str, float]:
    pre = w * x
    h = max(0.0, pre)
    y = v * h
    loss = 0.5 * (y - target) ** 2
    active = 1.0 if pre > 0.0 else 0.0
    return {
        "y": y,
        "loss": loss,
        "dw": (y - target) * v * active * x,
        "dv": (y - target) * h,
    }


def reparameterisation_case(c: float = 10.0) -> Dict[str, Dict[str, float]]:
    """Positive rescaling preserves y = v ReLU(w x) but changes raw gradients."""
    original = relu_pair(w=2.0, v=3.0, x=1.0, target=5.0)
    rescaled = relu_pair(w=2.0 * c, v=3.0 / c, x=1.0, target=5.0)
    return {"original": original, "rescaled": rescaled}


def depth_case(gain: float, depth: int) -> float:
    """Sensitivity through a scalar chain h_t = gain * h_(t-1)."""
    if depth < 0:
        raise ValueError("depth must be non-negative")
    return gain**depth


def run_audit() -> None:
    p = Params()
    x, target = 1.7, 0.4
    analytic = manual_gradient(p, x, target)

    print("Manual gradient versus central finite difference")
    for name, value in analytic.items():
        numeric = central_difference(p, x, target, name)
        scale = max(1.0, abs(value), abs(numeric))
        rel_error = abs(value - numeric) / scale
        print(f"  {name}: manual={value:+.8f}  finite={numeric:+.8f}  error={rel_error:.2e}")

    print("\nBounded intervention on w1")
    for delta in (-0.50, -0.05, -0.005):
        actual, predicted = bounded_effect(p, x, target, "w1", delta)
        print(f"  delta={delta:+.3f}  actual={actual:+.8f}  linear prediction={predicted:+.8f}")

    print("\nSaturation case")
    for key, value in saturation_case().items():
        print(f"  {key}: {value:+.8f}")

    print("\nFunction-preserving ReLU rescaling")
    twins = reparameterisation_case()
    for name, values in twins.items():
        print(f"  {name}: y={values['y']:.2f}, dw={values['dw']:.2f}, dv={values['dv']:.2f}")

    print("\nDepth sensitivity")
    for gain in (0.9, 1.0, 1.1):
        print(f"  gain={gain:.1f}, depth=60, product={depth_case(gain, 60):.6g}")


if __name__ == "__main__":
    run_audit()

sequenceDiagram
  participant Q as Question
  participant M as Mechanism
  participant E as Evidence
  participant D as Decision
  Q->>M: The error that does not travel backwards
  M->>E: An autodiff-free credit-assignment audit
  E-->>M: compare rival explanations
  E->>D: Use gradients to propose and interventions to authorise
  D-->>Q: revise scope or act

Use gradients to propose and interventions to authorise

When a model fails, do not ask which parameter or module is “to blame” and then sort by gradient magnitude. Ask what derivative was actually computed. Name the scalar loss, the data aggregation, the executed path, the coordinate system and the intervention scale.

Then separate the decisions. If you are debugging derivative code, a central finite-difference check may be enough. If you are choosing a small optimiser step, a verified local gradient may be enough. If you are deciding which module to redesign, freeze, replace or govern, demand finite intervention evidence, path tests and representation stability.

The chain rule remains one of the most powerful compression devices in machine intelligence. It converts one remote objective into local update information across a composite system. Its limitation is the mirror image of that power: it can only speak through the graph, loss and coordinates it has been given.

This creates a simple release discipline. Store gradients as decision receipts with the objective version, sample identifiers, aggregation rule, model state, graph boundaries and proposed step. For any change that is difficult to reverse, add the finite intervention result and at least one structural challenge. The receipt should state what passed, what failed and which inference remains prohibited. A naked heat map or component ranking is not a receipt.

The same discipline improves scientific claims. Saying that a parameter “matters” should specify whether it has a non-zero derivative, changes behaviour when intervened on, carries a unique path or retains its ranking across equivalent implementations. Those are different observations. Their separation makes negative results interpretable rather than embarrassing.

That decision discipline changes architecture as well as diagnosis. Preserve useful gradient routes with appropriate scaling and skip paths. Expose detachments and nondifferentiable boundaries. Report per-path or per-example cancellation where averages hide it. Compare changes in function space when parameter coordinates are arbitrary. Above all, keep optimisation credit distinct from causal responsibility.