Tensor-type string tensor<d₀x…xf32>.

Boolean (i1) tensor-type string, for compare/select masks.

bf16 tensor-type string: the convertF round node and the operands and results of the bf16 ops (dotInBf16, the …Bf16 convolutions).

fp8 peer of tyBf16. E4M3 only — f8E5M2 compiles, lowers to a plain __cublas$lt$matmul, and leaves ZERO f8e5m2 values in the optimized HLO: the type is silently widened away. Only E4M3 reaches the fp8 units on sm_89, so there is deliberately no E5M2 spelling here.

SSA name ↦ the [c,h,w] the value bound to that name really carries. See liftPointwise.

Keyed by NAME, not by flat width — and that is not a refinement, it is the whole correctness of the table. A width table collides whenever two layers have the same element count, and on the real nets they do: ConvNeXt-T's stage-2 MLP is 1536·14·14 = 301056 and its stage-0 block is 96·56·56 = 301056; stage 3's 3072·7·7 equals stage 1's 192·28·28. First writer won, so 24 of ConvNeXt's pointwise blocks unflattened to a shape with the right element count and the wrong layout — which is not a wrong program (the bracket is still an inverse reshape pair) but is exactly the relayout the bracket exists to remove. Keying by name cut ConvNeXt-T's transpose traffic by an order of magnitude and shortened its step (planning/archive/next_session_execution_and_parity.md).

Newest entry first, and no dedup: fresh never reuses a name, so a lookup for a value the previous token produced hits the head of the list.

The Bool is the value's LAYOUT: true means this is the map's row view [h·w, c] rather than the map [c, h, w]. It is not bookkeeping — it is what makes ConvNeXt's channel-LN transparent. That chain is transpose → lnRow → rowScale → rowBias → transpose, a layout ROUND TRIP whose two ends are the same [c,h,w] map; without the flag the closing transpose's result has no entry, the drop-path multiply that consumes it falls back to flat, and every pointwise op after it on the residual chain goes with it, which measurably grows ConvNeXt-T's relayout traffic (the same plan doc). And liftPointwise must NOT fire on a row view: [h·w, c] reshaped to [B,c,h,w] is a DIFFERENT permutation, not an inverse pair, so that one would be a wrong program rather than a slow one.

Emitter state: the fresh-name counter, plus the name ↦ [c,h,w] table.

The table lives in the STATE rather than in a pretty argument because a net renderer calls pretty once per graph FRAGMENT — a conv and the activation that consumes it land in different calls — and only the state is threaded across them.

Fresh SSA name %v{k}.

The row-max shift both max-shifted softmax emits share: {mx} = each row's max of the [B,m,n] scores {xn} (reduce maximum over [2] from -inf), broadcast back and subtracted, so {sh} = xn − max has every entry ≤ 0 and the exp that follows cannot overflow.

The 3×3/s2 pool's emitted forward text, given already-freshened names.

It is a shared helper rather than two copies for the reason sWGradGeom is: the per-example .maxPool3s2F and the batched BatchableOp.maxPool3s2 are two emitTok arms emitting one program, and a window or padding that drifted between them would be a pair of renders that agree on every structural check and compute different functions — which is the exact failure this whole op exists to fix. With one writer they cannot drift, and TestBatchedEmitTie then measures rather than assumes it.

window_dimensions = 3, window_strides = 2, padding = [[1,1],[1,1]] on the spatial axes: He et al./torchvision MaxPool2d(3, stride=2, padding=1), window i = input [2i−1, 2i+1]. NOT XLA 'SAME', which pads (0,1) and slides the grid one input position — the two are different functions everywhere.

The 3×3/s2 pool's emitted backward text, from the saved input xN and the cotangent r; returns the text and the output's name. Shared by the per-example and batched arms, for maxPool3s2FwdText's reason. It draws its own fresh names because it emits some fifty values.

This is maxPool3s2BackFlat written without stablehlo.select_and_scatter. No IREE release lowers that op when the windows OVERLAP — upstream StableHLO's linalg legalization handles only window = stride — so until 2026-10-28 neither ResNet compiled through the second lowerer at all (maxPoolBack's 2×2 windows tile, so it keeps the op). XLA lowers both spellings. The same function, as nine strided slices:

1. pad the input with -inf by one on each spatial side: window (oh, ow) is then the 3×3 block at [2oh, 2oh+2] × [2ow, 2ow+2] of the padded map, and a pad cell never wins a max because every window holds a real cell;
2. slice the padded map at each window offset (i, j) with stride 2 — s_ij[oh, ow] is the cell at offset (i, j) of window (oh, ow) — so one maximum over the nine is the forward's max m;
3. the first-max mask, in ROW-MAJOR window order: mask_ij = (s_ij = m) ∧ ¬claimed, with claimed the OR of the earlier equalities. That is the GE select's choice, a later equal never displacing an earlier one, and the windowArgmax the denotation names;
4. route: c_ij = select mask_ij dy 0;
5. scatter: pad c_ij with interior 1 and edges (i, 3−i) / (j, 3−j), which puts c_ij[oh, ow] at padded cell (2oh+i, 2ow+j), the cell it was read from;
6. SUM the nine — an input is the argmax of up to four windows and the cotangent accumulates, which is what the scatter region's add did — and slice the pad border off.

Checked at the stem shape (32×64×112×112) with ties forced: against XLA's own select_and_scatter (JAX CPU) and against an independent argmax/bincount reference, identical to 5e-7 — fp32 summation order, nothing else (atlas, 2026-10-28).

The 2×2/s2 pool's emitted forward text on the flat input r; returns the text and the output's name. One writer for the per-example .maxPoolF token and the batched "maxPool" descriptor, for maxPool3s2FwdText's reason. The windows tile, so there is no padding.

The region block arguments %pa/%pb/%pm are spelled out, so they are reserved SSA names.

The 2×2/s2 pool's emitted backward text, from the saved input xN and the cotangent r; returns the text and the output's name. One writer for the .maxPoolBack token and the batched "maxPoolBackP" tag. The windows tile, so stablehlo.select_and_scatter lowers in both compilers and stays (contrast maxPool3s2BackText).

NOTE the region block arguments %sa/%sb/%sc/%sd (and %sge/%ss) are HARDCODED, so they are reserved SSA names: a top-level value of the same name is a redefinition error, and it only surfaces at XLA compile time.

The stochastic-depth mask input name for ramp index i — the mName a dropPathB carries, and the tensor<Bxf32> the signature declares for it.

It lives HERE, beside the emitter, rather than in one net's renderer, because the spelling is load-bearing in three places that must agree and only one of them is Lean: dropPathP's emit reads it as an operand, every SD render's signature declares it, and scripts/probes/misplace_drop_sites.py matches %dp\d+ textually to build the placement control. A second definition would be the double-writer disease with a committed shell script as the third writer.

The classifier-dropout mask input name — the mName a dropoutB carries, and the tensor<B×n×f32> the signature declares for it.

IT IS DELIBERATELY NOT %dp{i}-SHAPED, and that is not cosmetic. scripts/probes/misplace_drop_sites.py builds the stochastic-depth placement control by matching %dp\d+ textually; a dropout input spelled %dp9 would be swept into that rewrite, silently changing a control's meaning on a render it was never written for. A control that quietly does nothing reads exactly like a control that ran, and the cheap defence is a name the SD tooling cannot match. grep -c '%do' verified_mlir/*.mlir is 0 across every committed artifact.

The (tag, names, info) skeleton descriptor of a batched per-example op — the discriminator + the SSA names the emit references + the shape dims. Keeps the batchOp skel one line and isolates the 7-variant match into a pure function.

Erase an SHlo graph to its renderable skeleton (drops ℝ values + shape index; keeps op structure, shapes, leaf names).

Postorder serialization: children, then the node's opcode token.

Stride-2 weight-gradient window geometry — odd AND even kernels. Returns (up, ext, lo, hi) for one spatial axis: up is the trailing zero row of the decimate-backward upsample, ext the resulting cotangent extent, and [lo, hi] the correlation's padding.

The strided weight grad zero-upsamples the cotangent onto the stride-1 grid (the decimate backward) and then correlates the saved input against it VALID-style, so the result is kH×kW. For an odd kernel the upsample carries a trailing zero row (up = 1, extent 2s) and the correlation pads symmetrically by p = (k−1)/2. That is the committed spelling for the 1×1, 3×3 and 7×7 kernels every other net uses, and it is reproduced here byte-identically.

For an even kernel p = (k−1)/2 floors to k/2 − 1, so a symmetric pad emits a result one short of k: at k = 2, input 8×8 → output 4×4, it declares 2x3x2x2 against a convolution yielding 1x1 — type-invalid MLIR. The even branch applies the same asymmetry convStridedBack applies on the input-VJP: drop the trailing zero row (extent 2s−1) and pad [p, k−2−p].

Output width is ext_padded − ext + 1 = (2s + lo + hi) − ext + 1: k=1 → (1, 2s, 0, 0) ⇒ 1; k=3 → (1, 2s, 1, 1) ⇒ 3; k=7 → (1, 2s, 3, 3) ⇒ 7; k=2 → (0, 2s−1, 0, 0) ⇒ 2; k=4 → (0, 2s−1, 1, 1) ⇒ 4.

The full entry — [c,h,w] plus the row-view flag — recorded for SSA name nm.

The [c,h,w] nm carries as a map. A row view answers none: it holds the same elements in a different order, so unflattening it to [B,c,h,w] would not be an inverse pair.

The [c,h,w] an op's INPUT and OUTPUT activations carry, when it has them. Strided and pooled tags carry their output spatial dims, so the input side is 2h × 2w.

Each batched tag and its per-example peer MUST answer IDENTICALLY. The two renders are tied byte for byte (tests/TestBatchedEmitTie.lean, convnext-fwd-b-tie), so a shape one path knows and the other does not is a liftPointwise that fires on one side only — a tie failure with no wrong answer anywhere to point at. Add tags in pairs.

Record nm ↦ [c,h,w] + layout, newest first. fresh never reuses a name, so an entry can never be contradicted by a later one; an .operand name re-pushed in a later fragment repeats.

Record nm as carrying the [c,h,w] MAP (not a row view).

The [c,h,w] the running table has for the value bound to nm, as a map.

The full entry the running table has for nm.

The ops that keep a value in its [h·w, c] ROW VIEW: ConvNeXt's channel-LN chain, which normalises over the transposed layout and hands the result back to the closing transpose.