The film
About 6:37, hosted by Rerun. It asks you one question and waits for your answer before it shows you. The guide's voice is not recorded yet, so for now the film plays with captions; the full words are also below.
Nothing loads until you press play.
The lab: the parity check
Pick a version of the arithmetic, a seed and whether the image has its glint, and run every pixel against the exact value with raw-native's own bound and measure. The image is a small synthetic stand-in built to the note's magnitudes: with the glint, the tensor-core arithmetic missed on 18 of 576 pixels at seed 1. The real chip's figure was 0.106689.
Everything is computed on your computer, in this page. Nothing is sent anywhere.
Everything the film says
The denoiser's tensor-core parity
Case study: the denoiser's tensor-core parity.
Last lesson measured where 16-bit numbers run out. Tonight Rerun follows a real case where they did: a check that failed, the search for why, and the fix that was not made.
Two paths, one check
raw-native is a renderer with a small neural denoiser. Its network runs two ways on the graphics chip: one on the tensor cores, with 16-bit inputs and weights and 32-bit sums, and one in plain 32-bit arithmetic.
Before either ships, a parity check compares every output value with a reference. The rule is fixed in advance: no value may differ by more than 0.01.
On an RTX 4090, over 64 frames, the 32-bit path's worst difference was 0.0029. The tensor-core path's was 0.1067, at frame 48.
The tensor-core path missed by ten times the bound. Wrong everywhere, or in a few places? (the film pauses here)
A few places
In a few places. Out of 24,883,200 values, the average difference was about six millionths, and 99.99 percent were under 0.0018.
A check on the average would have passed. This one asks for the worst value, so one bad pixel is enough to fail it.
Reproduce before fixing
Before trying any fix, the note on this miss wrote down its predictions, then ran the network on the main processor with the same 16-bit rounding.
The emulation missed by 0.1085, at the same frame and the same pixel as the chip. So 16-bit arithmetic alone reproduces the miss; no fault in the chip is needed to explain it.
The note had set out two guesses: the weights alone, or the inputs alone. Both were refuted as stated. Rounding only the weights gave 0.1370, and rounding only the inputs gave 0.1041, so either rounding by itself misses the bound.
A sun glint
The bad pixels were single sun glints. At frame 48, one sample on a glossy surface carried 1,087 units of light beside neighbours near 0.1.
The denoiser first divides by the surface's specular reflectance, 0.04 plus a small 0.01, which turns that sample into about 21,700. Its five by five filter then weighs it down to around a hundred: the note gives 105, against a reference of 110.
The arithmetic
Now the bound. Missing by no more than 0.01 on a value of 110 asks for about one part in ten thousand. Near 110, 16-bit marks are 0.0625 apart, as we measured last lesson.
The filter itself runs in 32-bit. The rounding happens earlier, in the 16-bit layers that compute the filter's weights. 16-bit numbers hold about one part in a thousand, and any error that size feeding the filter, times a value of 110, moves the answer by about a tenth.
We rebuilt that step at small scale, with a made-up glint of the same size. In our seeded case the stand-in misses by 0.0789 with 16-bit inputs and weights, and differs by only 0.00002289 in 32-bit; across 200 seeds it misses in 180. Take the glint away and every version passes. These are the stand-in's numbers, not the real network's.
Fixes that fell short
The natural fix is mixed precision: keep the most sensitive layers in 32-bit and the rest on the tensor cores.
In the emulation, with the full-resolution head in 32-bit, the worst difference fell to 0.0512. With three layers, 0.0341. With six, 0.0340, on 4 pixels. Still over.
None of the mixed splits tried met the bound; 32-bit throughout did.
The bound stays
So the tensor-core path stays unchanged this round, and its parity check still fails. The options named are 32-bit throughout, which costs speed, or a model change that keeps the filter away from values that large, for example filtering a squeezed range and expanding it after, which also affects image quality.
And the note says plainly that the bound is not loosened. In our view that is the lesson: a bound loosened after the miss is seen no longer tests the result. It is fitted to it.
Goodnight
Reproduce the miss, find the arithmetic, and leave the post where you planted it.
Goodnight.
Sources
Every claim in the film, with where it comes from and what that source does not prove. The numbers about the model are computed from its weights, which you can load and check: facts.json.
raw-native parity run on an RTX 4090. HarperZ9/raw-native at 9de6582, evidence/rr-h2-v4/rtx4090/v4-parity-raw_hero-validation.json. https://github.com/HarperZ9/raw-native/blob/9de6582e822c6eb1eca63de39f857e1be8913b5d/evidence/rr-h2-v4/rtx4090/v4-parity-raw_hero-validation.json
Used for: Tensor-core path max absolute difference 0.106689 at frame 48, pixel 64580; scalar fp32 path 0.00290298; 64 frames, 24,883,200 values each; p99.99 upper 0.00176668 for the tensor-core path; the perturbed-weights control fails as required.
Does not prove: Behaviour on other GPUs, other scenes or other network versions.
raw-native inference bounds. HarperZ9/raw-native at 9de6582, evidence/rr-inference-bounds.json and the parity measure in vk_rrnet.cpp. https://github.com/HarperZ9/raw-native/blob/9de6582e822c6eb1eca63de39f857e1be8913b5d/evidence/rr-inference-bounds.json
Used for: The parity bound: maximum absolute difference at most 1e-2, measured per value in double over every value.
Does not prove: That 1e-2 is the right bound for image quality; it is the bound set in advance.
raw-native evidence note on the tensor-core parity miss, 15 October 2026. HarperZ9/raw-native at 9de6582, evidence/rr-tc-note-2026-10-15.json (last changed at 6c06e62). https://github.com/HarperZ9/raw-native/blob/9de6582e822c6eb1eca63de39f857e1be8913b5d/evidence/rr-tc-note-2026-10-15.json
Used for: Predictions written before the emulation; weights-only hypothesis refuted; single-sample specular fireflies (radiance 1,087 beside neighbours near 0.1, demodulated by 0.05 to about 21,700, filtered to about 105 against a reference of 110); per-layer and mixed-precision results; decision: no change this round and the bound is not loosened.
Does not prove: That PyTorch's emulation reproduces the tensor cores' summation order.
raw-native CPU emulations W, A and WA. HarperZ9/raw-native at 9de6582, evidence/rr-tc-2026-10-15/emu-W.json, emu-A.json, emu-WA.json (commit a0e2cc0). https://github.com/HarperZ9/raw-native/blob/9de6582e822c6eb1eca63de39f857e1be8913b5d/evidence/rr-tc-2026-10-15/emu-WA.json
Used for: WA max 0.108489990234375 at frame 48, pixel 64580; W 0.13702392578125; A 0.104095458984375.
Does not prove: The GPU's exact arithmetic; it agrees on the worst location and the order of the miss.
raw-native mixed-precision runs. HarperZ9/raw-native at 9de6582, evidence/rr-tc-2026-10-15/keep-10.json, keep-10_1_9.json, keep-10_1_9_8_0_3.json. https://github.com/HarperZ9/raw-native/blob/9de6582e822c6eb1eca63de39f857e1be8913b5d/evidence/rr-tc-2026-10-15/keep-10.json
Used for: Layer 10 in fp32: 0.0512 (25 pixels over); layers 10, 1, 9: 0.0341 (12); layers 10, 1, 9, 8, 0, 3: 0.0340 (4).
Does not prove: That no other mixed-precision split would pass.
Night School's small re-creation of the denoiser's arithmetic. media/school/denoiser/facts.json, written by tools/school/fill_denoiser.mjs from system/school/denoiser.mjs: one convolution step and the 5 x 5 softmax filter with a synthetic glint of the note's magnitudes, in fp32, fp16 and bf16 variants, against raw-native's own bound and measure. https://github.com/HarperZ9/HarperZ9.github.io/tree/main/media/school/denoiser
Used for: The re-created tensor-core arithmetic misses at the glint pixel and the fp32 path passes; without the glint every variant passes.
Does not prove: Anything numeric about raw-native's network: the real frame, weights and 12 layers are not in its evidence, so every re-created number is synthetic.
Night School's precision measurements (lesson K24). media/school/precision/facts.json, written by tools/school/fill_precision.mjs. https://github.com/HarperZ9/HarperZ9.github.io/tree/main/media/school/precision
Used for: Near 110, fp16 values are 0.0625 apart.
Does not prove: Anything about the denoiser by itself.
What this lesson leaves out
The film's figures for the real denoiser come from raw-native's published evidence; the re-creation is synthetic, because the frame's pixel values and the network's weights are not in that evidence.
The emulations ran on a processor, not the tensor cores, so their summation order may differ from the chip's; they agree with it on the worst frame and pixel.
Three mixed-precision splits were tried, down to 0.0340; other splits were not, so the film says none of those tried met the bound.
Before this: Mixed precision (K24). Next, on the same beach: A score that carries its receipt (E25).