Imaging has one habit everywhere you look: it grades the light. Face recognition grades embedding scores out of a black box; image generation grades how photoreal the render looks; generative 3D grades the rendered frame— FID and FVD on views — and never asks whether the world underneath stayed the same world. Our lab’s one idea, pointed at imaging, is the opposite habit: hold the dark— the structure the pixels collapse from — and treat every image as one collapse of it. This post is what that math does across three directions with one move. It is also a kept negative: in each direction we pre-registered a reach— a fancier or learned upgrade meant to beat the simplest structure-first method — and in each direction our own test refuted it. The simple baselines are real and measured; the reaches are printed exactly where they failed.

Where we land:resolved — a kept, honest negative. Three learned reaches, each refuted by the lab’s own pre-registered test; the simple structure-first baselines win. Not a win we chased — one we kept.

1 · The move — dark, light, and one collapse

The math is one sentence: an image is not the thing; it is a collapse ofthe thing. Behind any set of observations there is a compact, view-stable structure — the dark — and each observation is that structure rendered under a nuisance: lighting, pose, viewpoint. So the engine’s primitive is project(image) → structure and reconstruct(structure) → image, and the whole field folds into three directions of that single move: in— project an observation to the held identity and match coordinates (recognition); out— move through the structure along a named direction and render (generation); across— hold one structure while views accumulate (3D). Everything below is those three directions, measured — reaches and all.

2 · Collapse in — recognition, and its refuted reach

The field’s default is a deep embedding: accurate at web scale, unreadable by construction. The structure-first version separates the nuisance from the identity as math— a from-scratch light-model (the Retinex/SQI family) solves the lighting, then a linear map (PCA → Fisherfaces) holds the identity as a coordinate you can print. On the classic hard-lighting benchmark (Yale-B: 38 subjects, 30 training images each, identical split for both sides) the CPU stdlib reading measures 0.993 / 0.995 against the convolutional net’s 0.924±0.011 / 0.965±0.003. Read the fence with the number: this is the few-shot, hard-lightingregime. Give a deep net a million identities and it wins — that is its regime, not this one.

The structure-first reading is also far lighter by construction— fewer parameters, fewer operations, no GPU anywhere. But read those op-counts next to the honesty panel, because they are structural counts, not wall-clock:

The honesty panel, three stories kept separate.Story one — structural — is the figure above. Story two — wall-clock today — goes against us: the GPU conv trains in 23 seconds; our pure-Python build takes 1,852 — an interpreter loses to compiled CUDA even while doing far less arithmetic. Implementation fact, not structure fact; printed, not hidden. Story three — the compiled floor where the op-counts become real seconds — is a projection, labelled as one. And the reach: we pre-registered an attempt to beat our own linear model with a learned embedding. Closed-set it passed (1.0000 vs 0.9890); open-set — strangers, the case that matters — it was REFUTED (0.9425 vs 0.9366 — above the linear, but short of the pre-registered +0.01 margin). The linear structure ships; the learned reach does not. Two properties come free with the reading: on-device (faces never leave the machine) and auditable(coordinates you can inspect, not activations you can’t).

3 · Collapse out — generation, where the fancy control lost

The field’s generators are astonishing at the light — photoreal anything — and that is exactly their governance problem: a machine that can render anyone can impersonate anyone. Run the collapse the other way through held structure and the trade inverts: movement along named directionsin structure-space (“older”, “smiling” — 37 attributes evaluated), inside a learned span — which means the generator cannot mint a stranger: geometry, not policy. The control is real and measured — held-out selectivity 1.151 against a random floor of 0.912. And the reach missed: our attempt to upgrade the control with a learned ridge head was REFUTED by its own pre-registration(0.988 mean selectivity, a 41% win-rate against the simple method’s bar of 60%). The plainest dark direction held; the fancy one did not.

4 · Hold across — 3D, where the reach was refuted

Generative 3D is the youngest direction and the clearest case of the field grading the light: benchmarks score rendered frames (FID/FVD) and never the held world— whether the structure underneath stays the same structure as views accumulate. The alpha builds the chain that question needs, from nothing: detection, a hand-built rotation-invariant descriptor (85% matching across a 45° rotation where a raw patch scores 2% — after a diagnosed failure at 1–12% taught us why), tilt simulation, per-feature affine, a RANSAC verifier on our own eigensolver and SVD (precision 68% → 88% under half-outliers), and incremental structure-from-motion — every stage scored against ground truth. Its first finding is the honest kind: our pre-registered reach (“the sophisticated chain will extend the map’s range”) was REFUTED. “Wide baseline” is not one thing, and no tool wins everywhere.

That refutation generalises the whole post: the regime picks the tool, and the simplest structure that fits the regime holds.It is the same lesson as the linear model beating the learned embedding on strangers, and difference-of-means beating the ridge head. Growing whole worlds on held, bonded structure — and the structure-first grading metric the field lacks — is the open aim, marked reaching until it survives its own pre-registered kill-tests like everything else here.

5 · What this says about the field

Three directions, one pattern. Where the task is structure the observer already understands — lighting on a face, a named attribute, a camera’s small step — writing the structure down measures well: accurate in the few-shot regime, lighter by construction, auditable because it is made of coordinates rather than activations, safe because its limits are geometric rather than promised. Where the task is open-world scale, the deep stacks win and we say so. But note what happened every time we reached pastthe simple structure to a fancier one: our own pre-registration refuted the reach — three times, in public. The argument the math leaves is narrow and kept: grade the dark, not the light; hold the structure, rent the pixels — and keep the reaches that miss.

Why our math sees more

Because it grades what the pixels collapse from— the structure, the dark — instead of the pixels themselves, and because it lays the fence before it reaches for the feature. Every reach in this post was named and pre-registered beforethe run, so when the learned embedding, the learned head, and the sophisticated chain each fell short, there was nowhere to hide the miss: it went on the page at full width. A method that keeps its refutations is the only kind whose survivors you can trust. So the math sees more twice over — it sees the structure a black box hides, and it sees its own reaches fail. That is the reading, and only what the test held is kept.

Sources & method