The crack that moved six centimetres

A camera inspects circuit boards on a conveyor. One board carries a short crack near its left edge. The next board carries the same crack six centimetres to the right. Nothing about the crack's shape, texture or severity has changed. Only its address in the image has changed.

The inspection system produces two outputs. The first is a board-level disposition: accept, review or reject. For that output, the crack should have the same effect wherever it appears. The second is a pixel mask that guides a human examiner to the damaged region. For that output, moving the crack must move the answer. A board-level score that follows the crack across the image is wrong. A mask that stays fixed while the crack moves is also wrong.

This small case exposes the central confusion. Convolution does not decide that location is irrelevant. It supplies a detector whose response changes location in step with the input. A later readout may collapse those responses into a location-free decision, preserve their coordinates for dense prediction, or combine them with explicit position when location is causal. Calling all three behaviours “invariance” hides the mechanism that makes each one correct.

A dense layer connected to fixed image coordinates can learn a different detector at every position. A convolutional layer makes a stronger bet: the local relation that signals a crack near the left edge is useful near the centre and near the right edge. The bet saves parameters and, more importantly, creates a particular response to translation. The feature does not vanish when the input moves. Its address changes.

The distinction matters because “recognise it anywhere” contains two operations. First, detect the same thing at many places. Second, decide whether those places matter to the requested output. Convolution mainly addresses the first. Pooling, spatial readout, coordinates, attention or a task-specific head address the second.

Part I

A detector that travels

Start with a small grey-scale image. At each grid location, place the same 3 by 3 stencil over the pixels, multiply corresponding entries and add the results. If the stencil resembles a short diagonal edge, locations containing that edge receive a large response. Deep-learning libraries usually implement cross-correlation rather than the mathematically flipped version of convolution, but learned kernels make that naming difference operationally minor. The essential feature is repeated use of one local operator.[1][2]

Now define a translation by a displacement δ. The translated image is (T_δx)(u) = x(u - δ). Under the ideal conditions of an infinite or periodic grid, unit stride and a consistently defined boundary, applying the detector after moving the image equals moving the detector response after applying it:

The equation is useful because it says exactly what the architecture promises. It does not say that the final prediction stays constant. It says that the representation transforms in a known way. If a later operator P takes the maximum or average over all spatial locations, then P(T_δz) = P(z) for translations that preserve the feature field. The composed classifier P ∘ C_K can therefore be invariant even though the feature map is equivariant. Global average pooling was introduced as a classification readout in Network in Network, partly to replace position-specific fully connected layers.[3][4]

Thought experiment: change only the requested output

Give two teams the same images, labels, training budget and convolutional trunk. Team A must answer “is a crack present?” Team B must return the crack's centre coordinate. Nothing about the visual evidence changes. Only the required output transformation changes.

Team A can aggregate across position because its target is unchanged by translation. Team B cannot. If Team B globally pools every feature map before predicting a coordinate, the architecture has destroyed the variable its loss needs. It may recover weak location cues from padding or background regularities, but those cues are accidents, not the intended mechanism. Adding coordinates or retaining a spatial map is not a concession that convolution failed. It is a deliberate change in the output contract.

This group-action form is more than notation. It prevents a common architecture error: asking whether a model is “invariant” without naming the transformation or the output. A system can be translation-invariant for class identity, translation-equivariant for segmentation, rotation-equivariant for an orientation field and explicitly sensitive to absolute position for a safety zone, all in one product.[6]

Part II

flowchart TD
  A["The crack that moved six<br/>centimetres"] --> B["A detector that travels"]
  B --> C["The assumptions inside a<br/>sliding kernel"]
  C --> D["Where the symmetry leaks"]
  D -. "re-test" .-> A
  classDef first fill:#0a1424,stroke:#D95545,stroke-width:2px,color:#e6f3ff
  classDef step fill:#0a1424,stroke:#3f7da0,stroke-width:1px,color:#e6f3ff
  class A first
  class B,C,D step

The assumptions inside a sliding kernel

Convolution is often introduced as a calculation, then justified after the fact by its success. The more useful view is to treat it as a bundle of assumptions. Those assumptions explain both the data efficiency of CNNs and the tasks on which their bias becomes awkward.

Locality: nearby values form reusable evidence

A small kernel says that useful low-level relations can be recognised from a bounded neighbourhood. Edges, corners, texture elements and short temporal motifs fit this assumption. A fully connected layer must separately learn how every distant input relates to every output. A local layer initially refuses most of those interactions.

Locality does not mean the network can never use global context. Stacking layers grows the receptive field. For L unit-stride layers with an odd kernel width k, the theoretical receptive-field width is R_L = 1 + L(k - 1). Here R_L is the side length of the input region that can affect one output unit. Increasing depth or kernel width enlarges that region. Stride and dilation enlarge it faster, but they also change sampling and resolution.

Theoretical reach is not the same as effective use. Gradients and learned weights may concentrate influence near the centre. A large receptive field also allows boundary effects to reach deep into an image. Kayhan and van Gemert showed that modern convolutional networks can exploit absolute position through padding-induced boundary cues, even far from the border.[7]

Weight sharing: the same relation matters at many addresses

The decisive constraint is not local connectivity alone. A locally connected network can use a separate 3 by 3 filter at every position. Convolution ties those parameters. One vertical-edge detector serves the entire field. This creates the translation symmetry of the parameters, which formal work connects directly to equivariance.[8]

Weight sharing converts examples across positions into evidence for the same parameters. A crack observed near the centre can improve the detector used near an edge. This is the main source of sample efficiency in the running case. It is also a restriction: the network cannot freely learn that the identical local patch means one thing in the sky and another on the road unless later context, boundary cues or explicit coordinates break the symmetry.

Stationarity: the sensor and task are sufficiently uniform

Applying the same kernel everywhere assumes that local statistics are comparable across the grid. Camera vignetting, lens distortion, spatially varying resolution, medical scanner geometry and map projections violate that assumption to different degrees. Sometimes calibration removes the variation. Sometimes the model needs coordinates, spatially varying filters or a geometry-aware operator. “Use convolution for images” is therefore too broad. The actual question is whether the relevant relation repeats under the transformation represented by parameter sharing.

Composition: larger structures can be assembled from local relations

Early convolutional systems, from Fukushima's neocognitron to LeNet-style document recognition, combined local receptive fields, shared feature extraction and spatial aggregation to tolerate changes in position.[9][10] The historical lesson is not that biological vision has been reproduced. It is that repeated local structure provides a powerful computational economy. Later layers can combine edges into parts and parts into objects without relearning each low-level relation at every address.

The strongest negative control: remove the need for translation

Suppose a trustworthy upstream system registers every board to sub-pixel accuracy, crops the same physical region and rejects any failed registration. The crack can no longer appear at arbitrary addresses. A dense model may then match or beat a convolutional model, especially when absolute layout is informative and the dataset is large. Translation sharing has less work to do because the environment has already canonicalised the nuisance variable.

This is a serious counterexample to the claim that convolution is intrinsically superior for pixels. Its advantage depends on repeated structure and transformations that remain in the data. The correct comparison is not “CNN versus MLP on images”. It is “which architecture encodes the symmetries, locality and output behaviour that the task still contains, at the available data and compute budget?”

Part III

Where the symmetry leaks

The clean commuting equation lives on an ideal domain. Real CNNs operate on finite arrays, change resolution, apply nonlinearities and receive images produced by sampled sensors. Each step can narrow or break the promised equivariance. The right response is not to abandon the concept. It is to state the exact boundary of the claim.

Finite images do not form an unrestricted translation group

Move a finite image far enough and content leaves the frame. New pixels must enter from somewhere. Zero padding, reflection, replication, circular padding and learned padding define different worlds outside the observed array. A patch near an edge therefore has a different neighbourhood from the same patch in the centre. The operation can remain well defined, but “the same image translated” is no longer a closed transformation unless the boundary rule is part of the specification.

This is not a minor implementation detail. Padding can become a coordinate system. If zero values occur only beyond the image boundary, deep filters can infer distance from that boundary. The network then gains absolute position sensitivity through a path that ordinary diagrams omit.[7] That sensitivity may help a dataset in which sky is usually above road, while hurting a deployment in which crops and camera framing change.

Stride changes the sampling phase

Take every second value in a feature map. A one-pixel input shift now changes which phase of the signal survives. Formally, downsampling by factor s generally satisfies translation equivariance only for shifts that are multiples of s. For other shifts, D_sT_δ ≠ T_δ/sD_s because δ/s is not an integer grid displacement.

High-frequency content makes the mismatch worse. The classical remedy is low-pass filtering before decimation, which reduces aliasing. Azulay and Weiss traced surprising sensitivity to small image transformations partly to violations of sampling assumptions.[13] Zhang showed that anti-aliased downsampling could improve shift stability and, in the studied architectures, also improve ImageNet accuracy and corruption robustness.[14] Later alias-free ConvNets extended the analysis to nonlinearities, arguing that downsampling fixes alone do not guarantee fractional-shift invariance.[15]

Pointwise operations preserve one symmetry; other layers may not

A pointwise ReLU commutes with integer translations because it applies the same scalar function at every address. Batch operations, normalisation across selected dimensions, interpolation, attention with positional terms and stochastic cropping require separate analysis. Recent work has derived conditions under which normalisation layers remain equivariant to discrete or continuous translations, illustrating that the property belongs to the complete computation, not the presence of a convolution somewhere inside it.[16]

Translation is only one transformation

Rotate a cat by ninety degrees and a standard 3 by 3 kernel does not rotate itself. Scale a lesion and the same kernel covers a different physical extent. Bend a road, change illumination or occlude a corner and no translation equation applies. Data augmentation can teach approximate robustness to these changes, but it does not convert ordinary translation sharing into an exact architectural symmetry.

Thought experiment: rotate only the camera mount

Two factories inspect identical circular parts. In Factory A, a keyed fixture fixes orientation. In Factory B, the part can arrive at any multiple of ninety degrees. Keep the defect distribution, camera, labels and training count unchanged. A standard CNN receives a useful translation prior in both factories, but Factory B also contains a rotation symmetry. It must learn rotated copies from data or use an architecture that shares across the rotation group.

Now alter one detail: a stamped serial number must remain upright in the final report. Full rotation invariance becomes wrong because orientation carries information for that subtask. The system needs rotation-equivariant features, followed by an invariant defect head and an orientation-sensitive text head. The transformation contract has become multi-output rather than globally invariant.

Exactness has a budget

Architecture discussions often treat equivariance as a badge that a network either owns or lacks. A deployed imaging chain is less tidy. The physical object moves continuously; the lens projects it; a sensor samples it onto a finite grid; registration estimates a frame; preprocessing crops and resizes; the network changes resolution; and the readout converts a field into a decision. An exact algebraic property at one layer can therefore coexist with a visibly unstable end-to-end system. Conversely, a network without a formal guarantee may be consistent enough inside the operating envelope.

Separate three claims: a layer-level guarantee, measured orbit consistency and useful task performance. The first follows from mathematics under declared boundary and sampling assumptions. The second is an empirical property of the complete pipeline. The third asks whether remaining variation changes a decision that matters. None implies the next. A classifier can be exactly invariant and consistently wrong. A segmenter can score highly on average while moving its mask by two pixels whenever the acquisition phase changes. A system can also violate exact equivariance by a tiny amount that stays below the physical tolerance of the process.

Return to the board inspector. Suppose the defect rule tolerates a one-millimetre localisation error, while one output pixel represents a tenth of a millimetre. A one-pixel mask wobble is then operationally small; an eleven-pixel wobble crosses the rule boundary. Those figures are illustrative, not measurements. Their purpose is to force the tolerance into physical units. The architecture review should allocate an error budget across registration, interpolation, network response and post-processing, then test whether their combined effect can cross a business threshold.

This view also answers a serious objection. Given enough varied data, a sufficiently expressive unconstrained model may learn the desired symmetry without specialised layers. That is a valid negative control, not a reason to ignore structure. The comparison should ask how much data, computation and failure coverage each route needs, and whether the learned behaviour remains stable near sparsely observed parts of the orbit. Architectural sharing earns its cost when the symmetry is credible, examples are scarce or consistency matters beyond average accuracy. Augmentation may be preferable when the transformation is only approximate, exceptions are common or a specialised operator would impose the wrong relation.

The practical target is therefore not maximum symmetry. It is the smallest, most testable transformation contract that removes nuisance variation while preserving causal variables. Measure exact smoke tests where the implementation promises exactness. Measure orbit error across the complete pipeline where exactness is impossible. Finally, connect that error to task thresholds. This three-level ledger prevents a formal guarantee from becoming a proxy for system quality, and prevents a good benchmark average from concealing unstable behaviour under motion.

Part IV

A matched experiment that separates detection from address

The accompanying artefact creates 16 by 16 synthetic images with sparse noise and one 3 by 3 pattern. The first task classifies a plus sign versus an L shape. Training examples place the pattern only in a central 4 by 4 region. The shifted test places it in unseen edge regions. The second task keeps the plus sign fixed as the only shape and asks whether it lies on the left or right. This location task is the negative control for invariance.

Four small models receive matched training counts and optimisation. A dense MLP has no weight sharing. A spatial CNN uses two convolutional layers but flattens the feature map into a position-specific head. A pooled CNN uses the same style of convolutional trunk followed by global max pooling. A coordinate-pooled CNN adds explicit x and y channels before the convolutions, allowing the pooled representation to break translation symmetry.

The experiment changes one causal feature at a time. The spatial CNN tests whether convolution alone creates an invariant classifier. The pooled CNN adds only an address-discarding readout. The coordinate model then restores access to address while retaining shared local detection. Five seeds are reported. The tenth and ninetieth percentiles describe variation across those seeds; they are not confidence intervals for a real deployment.

The spatial CNN is the decisive result. It contains shared convolutional filters and uses fewer parameters than the MLP, yet its shifted accuracy is at chance. Its detector can travel, but the final linear head learns which positions mattered during training. A translation-equivariant trunk does not rescue a position-specific readout.

Global max pooling changes the result. The pooled CNN reaches a median 100 per cent on shifted positions because the head asks whether a strong feature exists, not where it exists. The coordinate-pooled model also learns the shape, but its explicit address channels make the invariance softer and its shifted result more variable. That is expected: a model allowed to use position can exploit training-position regularities.

The counterexample: when successful invariance is the bug

On the left-versus-right task, the globally pooled CNN falls to 50.1 per cent, essentially chance. The architecture has done exactly what it was designed to do: discard where the feature occurred. The spatial CNN, dense MLP and coordinate-pooled CNN retain or reconstruct position and reach about 100 per cent.

This negative control prevents a shallow conclusion that more invariance is always better. The preferred architecture changes when the requested output changes, even though the input type and local evidence stay the same. CoordConv research made the same general point through coordinate-transform tasks: ordinary convolution can struggle when a task needs explicit access to position, and coordinate channels provide a direct symmetry-breaking path.[18]

stateDiagram-v2
  [*] --> Claim
  state "Thought experiment: change<br/>only the requested output" as Claim
  state "Locality: nearby values form<br/>reusable evidence" as Test
  state "Weight sharing: the same<br/>relation matters at many<br/>addresses" as Revision
  Claim --> Test: expose mechanism
  Test --> Decision: evidence survives
  Test --> Revision: rival survives
  Revision --> Claim: narrow or rebuild
  Decision --> [*]

A production-shaped decision: inspect the board, not the benchmark

A line-scan inspection system receives 4,096 by 4,096 images of assembled boards. Fiducial registration removes most displacement, but residual translation remains. Boards may enter at one of four right-angle orientations. The system must produce a defect mask, a board-level severity score and a zone-specific rule outcome because damage near a high-voltage connector has different consequences from the same damage near an unused edge.

A single demand for “invariance” would be incoherent. The defect mask should translate and rotate with the board. The severity score should remain stable under those same nuisance transformations, provided no content leaves the frame. The zone rule should be evaluated in board coordinates after orientation and registration are resolved. Absolute camera coordinates are irrelevant; calibrated board coordinates are causal.

A plausible design begins with registration quality checks, not a larger network. If registration confidence is high, canonicalising the four orientations may be cheaper and easier to validate than building a rotation-equivariant model. If orientation is ambiguous or the same detector must serve unregistered images, a group-equivariant or steerable trunk becomes a credible option. Cohen and Welling's group convolutions show how discrete rotations and reflections can be built into feature transformations; later Lie-group methods extend the idea to broader continuous symmetries.[11][12]

The trunk should preserve sufficient spatial resolution for the mask. Anti-aliased downsampling can be tested where stride is necessary. A dense decoder returns the mask in board coordinates. A global aggregation of defect features feeds the board-level severity head. The zone rule receives the mask plus calibrated coordinates, rather than hoping that zero padding teaches the network a stable map of the board.

The evaluation should follow the declared transformations. For each held-out board, construct an orbit of permitted translations and right-angle rotations. Transform the expected mask with the image; keep the expected severity fixed; recompute the zone result in board coordinates. Record where cropping makes the transformed case invalid. This produces three separate errors rather than one accuracy number.

This metric is not a substitute for ordinary quality evaluation. A consistently wrong model can be perfectly equivariant. Orbit consistency must be paired with accuracy, calibration, boundary cases and task utility. It answers one question only: does the system transform its answer in the way the task declares?

The transformation contract

The instrument changes the architecture review. Instead of asking whether CNNs are still competitive with another model family, it asks which transformation economy the system needs. A transformer with relative position, a CNN, a steerable network and a registered template pipeline can all be good answers to different contracts. Benchmark rank alone cannot decide among them.

The executable artefact

The Python program reproduces the two-task benchmark and runs three algebraic smoke tests. A unit-stride convolution with circular padding must commute with an integer translation. Global max pooling over that response must remain unchanged. A one-pixel shift followed by stride-two sampling must expose a phase error. The training experiment then supplies the positive case and the negative control.

Run python paper45_convolution_contract.py with Python 3.10 or later, NumPy and PyTorch. The fixed configuration uses five seeds, 1,200 training cases per task and CPU execution. The program asserts broad mechanism-level expectations rather than exact percentages, then prints median and seed-range results. All data are generated locally.

#!/usr/bin/env python3
"""Paper 45 artefact: convolution, equivariance, invariance and symmetry breaking.

The script contains two experiments on synthetic 16 x 16 images.

1. Shape task: learn '+' versus 'L' from central placements, then evaluate at
   unseen edge placements. This tests whether a detector travels with the input
   and whether the readout discards location.
2. Location task: every image contains the same '+'; predict left versus right.
   This is the negative control. A deliberately invariant readout should fail,
   while a spatial head or coordinate channels should succeed.

It also runs exact smoke tests showing that unit-stride circular convolution is
translation equivariant, global max pooling is invariant to that translation,
and stride-2 sampling breaks one-pixel equivariance by changing sampling phase.

Dependencies: Python 3.10+, NumPy and PyTorch. CPU execution is sufficient.
Expected runtime on a modern laptop CPU: tens of seconds, not minutes.
"""

from __future__ import annotations

import argparse
import json
import random
from dataclasses import dataclass
from statistics import median
from typing import Callable

import numpy as np
import torch
from torch import Tensor, nn
from torch.nn import functional as F
from torch.utils.data import DataLoader, TensorDataset

HEIGHT = WIDTH = 16
BASE_SEED = 45_045
REPLICATES = 5
EPOCHS = 8
TRAIN_CASES = 1_200
SEEN_CASES = 500
SHIFTED_CASES = 700
LOCATION_CASES = 700

PLUS = np.array(
    [[0.0, 1.0, 0.0],
     [1.0, 1.0, 1.0],
     [0.0, 1.0, 0.0]],
    dtype=np.float32,
)
ELL = np.array(
    [[1.0, 0.0, 0.0],
     [1.0, 0.0, 0.0],
     [1.0, 1.0, 1.0]],
    dtype=np.float32,
)
PATTERNS = (PLUS, ELL)

CENTRAL_POSITIONS = [(y, x) for y in range(5, 9) for x in range(5, 9)]
EDGE_POSITIONS = [
    (y, x)
    for y in (0, 1, 2, 11, 12, 13)
    for x in (0, 1, 2, 11, 12, 13)
]
# Keep the location task away from padding so the invariant model cannot infer
# coordinates from the image boundary. x >= 7 is the right-hand class.
LOCATION_POSITIONS = [(y, x) for y in range(3, 11) for x in range(3, 11)]


@dataclass(frozen=True)
class Interval:
    median: float
    p10: float
    p90: float

    @classmethod
    def from_values(cls, values: list[float]) -> "Interval":
        return cls(
            median=100.0 * median(values),
            p10=100.0 * float(np.quantile(values, 0.10)),
            p90=100.0 * float(np.quantile(values, 0.90)),
        )


class DenseMLP(nn.Module):
    """No spatial sharing: every pixel receives position-specific weights."""

    def __init__(self) -> None:
        super().__init__()
        self.network = nn.Sequential(
            nn.Flatten(),
            nn.Linear(HEIGHT * WIDTH, 64),
            nn.ReLU(),
            nn.Linear(64, 2),
        )

    def forward(self, x: Tensor) -> Tensor:
        return self.network(x)


class SpatialCNN(nn.Module):
    """Shared local detector followed by a position-specific linear readout."""

    def __init__(self) -> None:
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(1, 8, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv2d(8, 8, kernel_size=3, padding=1),
            nn.ReLU(),
        )
        self.head = nn.Sequential(
            nn.Flatten(),
            nn.Linear(8 * HEIGHT * WIDTH, 2),
        )

    def forward(self, x: Tensor) -> Tensor:
        return self.head(self.features(x))


class PooledCNN(nn.Module):
    """Shared detector plus global max pooling: deliberately location invariant."""

    def __init__(self) -> None:
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(1, 8, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv2d(8, 8, kernel_size=3, padding=1),
            nn.ReLU(),
        )
        self.head = nn.Sequential(
            nn.AdaptiveMaxPool2d(1),
            nn.Flatten(),
            nn.Linear(8, 2),
        )

    def forward(self, x: Tensor) -> Tensor:
        return self.head(self.features(x))


class CoordPooledCNN(nn.Module):
    """Global pooling with explicit x/y channels that permit symmetry breaking."""

    def __init__(self) -> None:
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 8, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.Conv2d(8, 8, kernel_size=3, padding=1),
            nn.ReLU(),
        )
        self.head = nn.Sequential(
            nn.AdaptiveMaxPool2d(1),
            nn.Flatten(),
            nn.Linear(8, 2),
        )
        yy, xx = torch.meshgrid(
            torch.linspace(-1.0, 1.0, HEIGHT),
            torch.linspace(-1.0, 1.0, WIDTH),
            indexing="ij",
        )
        self.register_buffer("coordinates", torch.stack((xx, yy)).unsqueeze(0))

    def forward(self, x: Tensor) -> Tensor:
        coords = self.coordinates.expand(x.shape[0], -1, -1, -1)
        return self.head(self.features(torch.cat((x, coords), dim=1)))


MODEL_FACTORIES: dict[str, Callable[[], nn.Module]] = {
    "Dense MLP": DenseMLP,
    "Spatial CNN": SpatialCNN,
    "Pooled CNN": PooledCNN,
    "Coord-pooled CNN": CoordPooledCNN,
}


def make_dataset(
    count: int,
    positions: list[tuple[int, int]],
    seed: int,
    task: str,
) -> tuple[Tensor, Tensor]:
    """Create noisy synthetic images for either the shape or location task."""

    rng = np.random.default_rng(seed)
    images = np.zeros((count, 1, HEIGHT, WIDTH), dtype=np.float32)
    labels = np.zeros(count, dtype=np.int64)

    for index in range(count):
        y, x = positions[int(rng.integers(0, len(positions)))]
        image = rng.normal(0.0, 0.12, (HEIGHT, WIDTH)).astype(np.float32)

        if task == "shape":
            label = int(rng.integers(0, 2))
            image[y : y + 3, x : x + 3] += PATTERNS[label]
        elif task == "location":
            label = int(x >= 7)
            image[y : y + 3, x : x + 3] += PLUS
        else:
            raise ValueError(f"Unknown task: {task}")

        # Sparse non-causal distractors prevent a trivial clean-template lookup.
        for _ in range(3):
            yy = int(rng.integers(0, HEIGHT))
            xx = int(rng.integers(0, WIDTH))
            image[yy, xx] += float(rng.uniform(0.2, 0.5))

        images[index, 0] = image
        labels[index] = label

    return torch.tensor(images), torch.tensor(labels)


def reset_and_train(
    model: nn.Module,
    dataset: tuple[Tensor, Tensor],
    seed: int,
) -> nn.Module:
    """Train one small classifier deterministically on CPU."""

    torch.manual_seed(seed)

    def reset(module: nn.Module) -> None:
        if hasattr(module, "reset_parameters"):
            module.reset_parameters()  # type: ignore[attr-defined]

    model.apply(reset)
    loader = DataLoader(
        TensorDataset(*dataset),
        batch_size=64,
        shuffle=True,
        generator=torch.Generator().manual_seed(seed),
    )
    optimiser = torch.optim.Adam(model.parameters(), lr=0.003)
    criterion = nn.CrossEntropyLoss()

    model.train()
    for _ in range(EPOCHS):
        for inputs, targets in loader:
            optimiser.zero_grad()
            loss = criterion(model(inputs), targets)
            loss.backward()
            optimiser.step()
    return model


@torch.no_grad()
def accuracy(model: nn.Module, dataset: tuple[Tensor, Tensor]) -> float:
    model.eval()
    inputs, targets = dataset
    predictions = model(inputs).argmax(dim=1)
    return float((predictions == targets).float().mean())


def parameter_count(model: nn.Module) -> int:
    return sum(parameter.numel() for parameter in model.parameters())


def exact_mechanism_tests() -> dict[str, float]:
    """Positive and negative tests for the algebra described in the article."""

    torch.manual_seed(BASE_SEED)
    signal = torch.randn(1, 1, 16, 16)
    kernel = torch.tensor(
        [[[[0.0, 1.0, 0.0],
           [1.0, -4.0, 1.0],
           [0.0, 1.0, 0.0]]]],
        dtype=torch.float32,
    )

    def circular_correlation(x: Tensor) -> Tensor:
        return F.conv2d(F.pad(x, (1, 1, 1, 1), mode="circular"), kernel)

    shift = (2, -3)
    moved_signal = torch.roll(signal, shifts=shift, dims=(-2, -1))
    moved_response = circular_correlation(moved_signal)
    response_moved_afterwards = torch.roll(
        circular_correlation(signal), shifts=shift, dims=(-2, -1)
    )
    equivariance_error = float(
        (moved_response - response_moved_afterwards).abs().max()
    )

    invariant_error = float(
        (moved_response.amax(dim=(-2, -1))
         - circular_correlation(signal).amax(dim=(-2, -1)))
        .abs()
        .max()
    )

    # A one-pixel shift changes which samples survive stride-2 decimation.
    impulse = torch.zeros(1, 1, 8, 8)
    impulse[0, 0, 2, 2] = 1.0
    shifted_impulse = torch.roll(impulse, shifts=1, dims=-1)
    stride_phase_error = float(
        (impulse[:, :, ::2, ::2] - shifted_impulse[:, :, ::2, ::2])
        .abs()
        .sum()
    )

    assert equivariance_error < 1e-6, equivariance_error
    assert invariant_error < 1e-6, invariant_error
    assert stride_phase_error > 0.9, stride_phase_error

    return {
        "unit_stride_circular_equivariance_max_error": equivariance_error,
        "global_max_invariance_max_error": invariant_error,
        "one_pixel_stride2_phase_error": stride_phase_error,
    }


def run_benchmark() -> dict[str, object]:
    torch.set_num_threads(1)
    random.seed(BASE_SEED)
    np.random.seed(BASE_SEED)
    torch.manual_seed(BASE_SEED)

    raw: dict[str, dict[str, dict[str, list[float]]]] = {
        "shape": {
            name: {"seen": [], "shifted": []} for name in MODEL_FACTORIES
        },
        "location": {
            name: {"accuracy": []} for name in MODEL_FACTORIES
        },
    }

    for replicate in range(REPLICATES):
        seed = BASE_SEED + 100 * replicate
        shape_train = make_dataset(TRAIN_CASES, CENTRAL_POSITIONS, seed + 1, "shape")
        shape_seen = make_dataset(SEEN_CASES, CENTRAL_POSITIONS, seed + 2, "shape")
        shape_shifted = make_dataset(
            SHIFTED_CASES, EDGE_POSITIONS, seed + 3, "shape"
        )
        location_train = make_dataset(
            TRAIN_CASES, LOCATION_POSITIONS, seed + 4, "location"
        )
        location_test = make_dataset(
            LOCATION_CASES, LOCATION_POSITIONS, seed + 5, "location"
        )

        for model_index, (name, factory) in enumerate(MODEL_FACTORIES.items()):
            shape_model = reset_and_train(factory(), shape_train, seed + 10 + model_index)
            raw["shape"][name]["seen"].append(accuracy(shape_model, shape_seen))
            raw["shape"][name]["shifted"].append(
                accuracy(shape_model, shape_shifted)
            )

            location_model = reset_and_train(
                factory(), location_train, seed + 20 + model_index
            )
            raw["location"][name]["accuracy"].append(
                accuracy(location_model, location_test)
            )

    summary: dict[str, object] = {
        "configuration": {
            "replicates": REPLICATES,
            "epochs": EPOCHS,
            "train_cases_per_replicate": TRAIN_CASES,
            "seen_shape_cases_per_replicate": SEEN_CASES,
            "shifted_shape_cases_per_replicate": SHIFTED_CASES,
            "location_cases_per_replicate": LOCATION_CASES,
            "base_seed": BASE_SEED,
        },
        "mechanism_tests": exact_mechanism_tests(),
        "shape_task": {},
        "location_task": {},
    }

    for name, factory in MODEL_FACTORIES.items():
        summary["shape_task"][name] = {  # type: ignore[index]
            "parameters": parameter_count(factory()),
            "seen_accuracy_percent": Interval.from_values(
                raw["shape"][name]["seen"]
            ).__dict__,
            "shifted_accuracy_percent": Interval.from_values(
                raw["shape"][name]["shifted"]
            ).__dict__,
        }
        summary["location_task"][name] = {  # type: ignore[index]
            "parameters": parameter_count(factory()),
            "accuracy_percent": Interval.from_values(
                raw["location"][name]["accuracy"]
            ).__dict__,
        }

    # Discriminating assertions. These are intentionally broad enough to avoid
    # treating a tiny synthetic benchmark as a precision contest.
    pooled_shifted = summary["shape_task"]["Pooled CNN"][  # type: ignore[index]
        "shifted_accuracy_percent"
    ]["median"]
    spatial_shifted = summary["shape_task"]["Spatial CNN"][  # type: ignore[index]
        "shifted_accuracy_percent"
    ]["median"]
    pooled_location = summary["location_task"]["Pooled CNN"][  # type: ignore[index]
        "accuracy_percent"
    ]["median"]
    coord_location = summary["location_task"]["Coord-pooled CNN"][  # type: ignore[index]
        "accuracy_percent"
    ]["median"]

    assert pooled_shifted > 95.0, pooled_shifted
    assert spatial_shifted < 65.0, spatial_shifted
    assert 45.0 <= pooled_location <= 55.0, pooled_location
    assert coord_location > 95.0, coord_location
    return summary


def print_table(summary: dict[str, object]) -> None:
    print("\nShape task: '+' versus 'L'\n")
    print(f"{'Model':<19} {'Params':>8} {'Seen median':>13} {'Shifted median':>16}")
    print("-" * 61)
    for name, row in summary["shape_task"].items():  # type: ignore[union-attr]
        seen = row["seen_accuracy_percent"]
        shifted = row["shifted_accuracy_percent"]
        print(
            f"{name:<19} {row['parameters']:>8,d} "
            f"{seen['median']:>6.1f}% [{seen['p10']:.1f}, {seen['p90']:.1f}] "
            f"{shifted['median']:>6.1f}% [{shifted['p10']:.1f}, {shifted['p90']:.1f}]"
        )

    print("\nLocation task: left versus right\n")
    print(f"{'Model':<19} {'Params':>8} {'Accuracy median':>28}")
    print("-" * 59)
    for name, row in summary["location_task"].items():  # type: ignore[union-attr]
        result = row["accuracy_percent"]
        print(
            f"{name:<19} {row['parameters']:>8,d} "
            f"{result['median']:>6.1f}% [{result['p10']:.1f}, {result['p90']:.1f}]"
        )

    print("\nMechanism tests")
    for name, value in summary["mechanism_tests"].items():  # type: ignore[union-attr]
        print(f"  {name}: {value:.8f}")


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--json",
        action="store_true",
        help="Print the complete result as JSON instead of compact tables.",
    )
    args = parser.parse_args()

    summary = run_benchmark()
    if args.json:
        print(json.dumps(summary, indent=2))
    else:
        print_table(summary)


if __name__ == "__main__":
    main()

sequenceDiagram
  participant Q as Question
  participant M as Mechanism
  participant E as Evidence
  participant D as Decision
  Q->>M: The crack that moved six centimetres
  M->>E: Thought experiment: change only the requested output
  E-->>M: compare rival explanations
  E->>D: Choose the motion before the model
  D-->>Q: revise scope or act

Choose the motion before the model

The durable intuition is simple. A convolutional kernel is a detector on rails. Move the evidence, and the detector response should move with it. That is translation equivariance. The detector has not yet decided whether location matters. The readout makes that decision.

This distinction turns a vague architecture preference into a testable design. Use global aggregation when the requested answer should stay fixed. Preserve a spatial field when the answer should move. Add calibrated coordinates or pose when a reference frame is causal. Extend parameter sharing to rotations or other groups only when those transformations belong to the task. Treat padding, stride and sampling as part of the claim, not as plumbing.

The changed decision is to stop selecting a CNN because the input is an image. Select or reject convolution after writing the transformation contract: which local relations repeat, which motions preserve meaning, how each output should transform, where symmetry must break and how the complete system will be tested across its valid orbit. That contract is the real inductive bias. The architecture is its implementation.