The zero constant bound to every conv's bias operand. R50 is bias-free (convBnNB), but the proven conv ops still TAKE a bias, so it binds to %zb{c} and zeroBiasPrelude emits those constants once at the top of the body. Routed through biasName rather than spelled inline so the naming has one definition shared with R34's renderer.

One bottleneck block's parameters, in bneckIdBlk order: W1 g1 bt1 W2 g2 bt2 W3 g3 bt3, plus Wp gp btp LAST when it projects. The projection going last is not cosmetic — it is bneckDownBlk's order and therefore the order the driver's [θ|m|v] walk assumes.

One bottleneck STAGE's parameters: block 0 projects (channels change, and in stage 1 that is the only thing that changes), the rest are identity blocks reading oc.

The 161 R50 parameter inputs, in func-arg order: stem (3), the [3,4,6,3] bottleneck stages, then the head. Single source for %p, %pm, %pv and the return order.

The same list as MLIR types. Derived, so the shapes have one definition.

One block's BN running-stat slots, in BN-forward order n1 n2 n3 [np].

The 106 running-stat inputs — 53 BN layers × (μ, var), μ and var interleaved per layer, which is how the driver packs runningBnStats off bnChannels.

R50's stochastic-depth site count — one per bottleneck block, [3,4,6,3] = 16.

It is the count the RAMP's denominator is read against (totalDrop − 1 = 15), so it is a definition rather than a literal 16 sprinkled at three sites.

The %dp0 … %dp15 mask arguments, tensor<Bxf32> each — appended to the train step's signature only under sd. Mirrors cnxDropSig.

some i under sd, none otherwise — the per-block ramp index handed to the six block emitters. The index is the BLOCK index and the two coincide here, because every R50 bottleneck drops; EfficientNet's do not (its reference advances the ramp counter inside a skip guard), which is why efficientnetVerified.dropKeeps is a literal array and this is a range. At sd := false this is none at every site and NOT ONE pretty call happens, so every committed R50 artifact re-renders byte-identically.

Identity bottleneck forward: 1×1 → BN → relu → 3×3 → BN → relu → 1×1 → BN → (+x) → relu, all at hh, channels oc → mid → mid → oc.

Stride-1 projection bottleneck forward — R50 stage 1 block 0, and nowhere else. cin → mid → mid → oc with the resolution unchanged, so the projection is a plain 1×1 conv → BN, NOT the strided one bnkStridedFwdB uses.

Strided projection bottleneck forward — stages 2/3/4 block 0. cin → mid → mid → oc, 2hh → hh.

conv1/bn1/relu1 run at the input resolution 2hh; only conv2 (the 3×3) is strided. v1.5.

Identity bottleneck backward + its 9 parameter gradients.

Cotangent chain: da (output relu) → bn3 → conv3 → relu2 → bn2 → conv2 → relu1 → bn1 → conv1, then dx = dc1 + da (the identity skip carries da unchanged). Each BN's γ/β gradient reads the cotangent at that BN's OUTPUT: da for bn3, dr2 for bn2, dr1 for bn1 — off by one and the gradient is silently wrong.

Stride-1 projection bottleneck backward + its 12 parameter gradients — stage 1 block 0. Identical to the identity backward except the skip branch carries its own bn→conv backward (dnp/dcp) and dx = dc1 + dcp.

Strided projection bottleneck backward + its 12 parameter gradients — stages 2/3/4 block 0.

dc2 is the STRIDED conv backward, so it takes the cotangent from hh back up to 2hh; everything upstream of it (dr1, dn1, dc1, W1's grad) lives at 2hh.

Stem forward at ladder base q (input 32q): 7×7/s2 conv → batch BN → relu → He et al.'s 3×3/s2 max-pool on %x, output at 8q. ResNet-34's stem at another resolution (same record). 2*q1 rather than a name, because convStrided (h := q1) demands its operand at exactly Vec (B*(3*(2*q1)*(2*q1))) and any other spelling of the same number is a different TERM.

Head forward: GAP(q×q) → dense(2048→nClasses) on the last block's output xName. Returns the text and the GAP and logit names.

The ResNet-50 forward chain at the BATCHED index — one traversal, consumed by both @resnet50_fwd and the train step that differentiates it.

ResNet-50 [3,4,6,3] bottleneck train step, batch-BN, rendered at N := B.

161 θ / 161 m / 161 v, %lr/%bc1/%bc2, 106 running-stat slots and %onehot in; 161 θ' / 161 m' / 161 v', %loss/%bc1/%bc2 and 106 batch stats out. Parameter ORDER comes from r50SigList, the same single source the signature and the return list use, so the arity/order contract cannot drift within this file — and it is written to agree with VerifiedSpec.bottleneckStageSpec, which is what the DRIVER walks.

The block sequence is [3,4,6,3] with block 0 of every stage projecting. Stage 1's projects at stride 1 (bnkProjFwdB); stages 2/3/4 project strided.

Identity bottleneck forward, per-example vocabulary.

Stride-1 projection bottleneck forward — stage 1 block 0. The projection is .flatConvF, NOT .flatConvStridedF.

Strided projection bottleneck forward. conv1/bn1/relu1 at 2hh; only conv2 strides.

The R50 EVAL forward: stem → [3,4,6,3] bottlenecks → GAP(q×q) → dense(2048→nClasses), every BN at frozen running statistics (bnEvalSite). Writes @resnet50in_fwd_eval.

@resnet50in_fwd — 162 inputs (%x + 161 params), logits [B, nClasses]. Batch-statistic BN: rendered from r50FwdChainB, the traversal the train step differentiates, so check_adam_prefix holds it as a byte prefix of the train step.

r50FwdChain is the eval-only chain (every BN a bnEvalSite), so the batch-statistic forward must be rendered from r50FwdChainB, as this function does.

@resnet50in_fwd_eval — the inference forward, every BN site reading frozen running stats. 161 params + 106 stat inputs + %x = 268 inputs. This is what the driver scores through, so its BN order must match r50StatSigList, which it does by sharing the chain.