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

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

bf16 tensor-type string, for the convertF round node (planning/archive/bf16_renderer.md). Only the round trip uses it today; when a bf16-operand dot_general lands (rung 2+) this is the type its operands carry.

fp8 peer of tyBf16. E4M3 only — planning/archive/cifar_lowprec_stability.md §2.3 measured that 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. Measured: 2.434 GB of transposes and 84.45 ms/step keyed by width, 0.122 GB and 68.28 ms keyed by name.

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 — 0.223 GB of relayout against 0.122 (measured, ConvNeXt-T bf16). 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 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 (§2f-bis): 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, given already-freshened names. Shared by the per-example and batched arms, for maxPool3s2FwdText's reason.

⭐ Only the window attributes differ from maxPoolBack's emit — nothing else — because select_and_scatter's scatter region already reduces with add, which is exactly the accumulation overlapping windows need. The emitter was general enough before the op existed.

⚠ %sa/%sb/%sc/%sd are hardcoded region block arguments and are therefore RESERVED SSA names (§4): a top-level value of the same name is a redefinition error that surfaces only 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/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. (It started in EfficientNetRender.lean and moved when ConvNeXt needed it too; both renderers are in this namespace, so no call site changed and no artifact byte moved.)

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/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. Handoff §0.11 records the other half of this hazard on ViT — 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.

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.

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.

Record what one token's operand and result carry, given the operand-name stack before and after it was emitted. Called from serializeToks, so no emitTok arm has to know about the table — which is what keeps the 94 arms free of it.

⭐ Three cases, and the first two exist only for the channel-LN round trip: a transpose FLIPS the layout flag when its (m,n) match the operand's [c,h,w] (and records nothing when they do not, e.g. ViT's attention transposes, which are not maps at all), and the row ops carry it through unchanged. Everything else reads its shapes off the tag.

Render a pointwise block at its 4-D shape when the OPERAND's producer recorded one. k receives the (possibly unflattened) input name and the dims to type its ops with, and returns (text, result name).

⚠ The c*h*w == n guard is what keeps a mismatched entry from emitting an ill-typed reshape rather than merely a suboptimal one. It cannot fire today — an entry is written by the token that produced the name — and it is the difference between a missed optimisation and a render that does not parse, so it stays.

⭐ The block's own RESULT is recorded too, which is what lets a pointwise CHAIN stay 4-D: the value crossing the token boundary keeps its flat type, so without this the second op in a swish→multiply→add chain would find nothing for its operand and drop back to flat.

Two-tensor-operand peer of liftPointwise; both operands carry the same flat width. The shape comes from whichever operand has one — the cotangent first, since it is the stack operand and was produced nearby, then the saved activation.

The text of the cross-replica mean — ViTRender.emitGradAllReduce's body, verbatim, so that the allReduceMean token re-renders every committed *dp* artifact byte-identically. all_reduce(add) over replica_groups = [[0..R-1]], then a divide by R; the names are %arsum{t} … %armean{t} from the tag rather than fresh. At R ≤ 1 there is no text and the operand's name is the result, exactly as the text function did.

The compute precision a contraction tag asks for: …Bf16 bf16, …F8 fp8 (E4M3), otherwise f32 (none) — as the type printer of the low-precision operands.

One contraction at a compute precision — the stablehlo.convolution / dot_general line of an emit arm, op lhs rhs being its text between = and the type signature. lp = none is the f32 op. lp = some t converts both operands to t and types the op in t; with lowResult the result is t too and is converted back to f32 — the bf16 / fp8 shape (an f32-typed conv result compiles to pure f32, flatConvFBf16) — and without it the result stays f32, the dot shape whose f32 result IS the accumulator (dotInBf16). Names are drawn in that order (the two converts, the op, the convert back), so an arm draws the same %v numbers at every precision. Returns the text and the f32 result's name.

The input-side dense contraction x · W (dotIn / dotInBf16).

The flat-carrier SAME conv + bias (flatConvF / flatConvFBf16): reshape the [B, ic·h·w] carrier to NCHW, convolve at lp's precision (emitContract), add the broadcast bias, flatten.

The flattened batched matrix multiply C = A·B (matmulF / "matmulFBf16"): reshape both operands to rank 3, dot_general with batching dim 0 (A's last axis against B's middle) at lp's precision, reshape back to flat.

The squeeze-excite activations inside one seBlock emission, by name: the squeeze (GAP, [B,c]), the reduce dense + bias ([B,r]), its swish, and the excite dense + bias ([B,c]) — the four values the SE backward reads. k0 is the fresh-name counter when the seBlock token is emitted. The offsets are the order the "seBlock" arm of emitTok below calls fresh in (sq 5th, ex 8th, a1 10th, h2 13th); the #guard after emitTok checks each name is defined by the op it claims. A renderer that saves these reuses the SE the forward already computes instead of emitting a second, un-fused copy.

Render one token: pop its operands' result-names off the stack, emit its StableHLO line(s), push its fresh result name. The per-op StableHLO syntax here is the audited lexical boundary (validated by iree-compile + GPU run); the structure it consumes is the proven-faithful token stream.

Fold a token stream to accumulated (code, result-name-stack).

The bias's slot in a return-name list, gated the way biasName gates the operand: with convBias := false no bias SGD op is emitted, so the slot must LEAVE the list rather than carry the empty string the if convBias then … else pure ("", "") idiom hands back.

⚠ This exists because leaving it in is silent twice over. An empty name renders return %a, , %b — malformed text, but only the lowerer ever sees it; and the name list keeps its FULL length, so an arity #guard on the signature still passes. Measured on the first swap attempt: mobilenetv2_train_step at convBias := false returned 210 names (52 of them empty) against 160 types. Use this at every site where a names := [...] list is built from gated ops.

The zero-bias constants the convBias := false render consumes, one per channel width used as a conv bias. Emitted once at the top of the body; XLA folds the resulting add.

Fixed-6-decimal float literal, so a computed smoothing constant emits in the SAME textual form the hand-written literals used and nClasses = 10 re-renders byte-identical.

Fixed-12-decimal float literal, for constants fmt6 would destroy.

⚠ It exists because fmt6 is not a formatting preference, it is a PRECISION CEILING, and small derived constants fall straight through it. Gradient accumulation's second-moment coefficient is (1−β₂)/K²; at K = 4 that is 6.25e-5, which fmt6 emits as 0.000063 — 0.8% wrong, in a baked literal, in the optimizer, where nothing downstream would question it. Same class as §2k's hardcoded 0.010000 label-smoothing mass. fmt6 stays the default so every committed artifact re-renders byte-identically; this is for constants that need the room.

The label-smoothing mass per class, α/K. α = 0.1 throughout; K is nClasses.

⚠ This was hardcoded 0.010000 — correct at K = 10 and WRONG at every other K, and it sat in the COTANGENT, not just in the report-only %loss. At nClasses = 1000 it made the smoothing term 100× too large: it removes 10.0 of probability mass instead of 0.1, i.e. a different objective, silently. Caught 2026-07-30 by the first ImageNet smoke run reporting loss ≈ 87 where 1000-class CE at init must be ≈ ln(1000) = 6.9 — the number was implausible, and that is the only reason it surfaced. Nothing in the repo's proofs covers it: α is a literal in emitted text, which is exactly the carve-out class §5 says needs its own numeric check, and §2b's %loss bug is the standing precedent for it going wrong unnoticed.

1 − α, the ON-class weight of label-smoothed CE. Emitted beside alphaOverK, because the two always move together and splitting them is how one of them gets updated alone.

1 − ρ, the RMSProp mean-square mixing weight. Derived from ρ, never written as a second literal beside it — the oneMinusAlpha precedent, and the K-constant lesson (§2k): any emitted constant that depends on a hyperparameter must be DERIVED, because the copy is what gets left behind when the original moves. Five copies of one label-smoothing constant were found across four nets in a single session for exactly this reason.