ViT-Tiny — every parameter gradient node IS the loss's derivative in that parameter #

vit_net_tiedGB says each of the 200 parameter gradient nodes denotes its layer's parameter Jacobian contracted with the cotangent the emitted backward chain threads to it, the chain's top being the smoothed-loss cotangent. vit_net_lossGrad composes that with the chain: for any loss L of the logits whose gradient at the net's output is g, the loss of the WHOLE net vitNetB with that one parameter varied is differentiable in it and every node is its gradient (HasGradAt). vitNetB is the tie's forward, batched, at its stochastic-depth sites sd; at none it is batchMap N of the canonical vitForwardKV at the twelve blocks (vitNetB_eq_vitForwardKV). vit_net_lossGrad_smoothedCE discharges hL for the label-smoothed loss the artifacts ship (smoothedBatchLossDiv, whose gradient is the softmaxDiv cotangent the render emits).

How. ConvNeXt's shape (ConvNeXtParamGrad.lean): no ViT op couples examples, so the work is per example and lifted once.

• Per example (at variable widths): the loss read after each of a block's eight parameterised ops has the tie's own per-example cotangent as its gradient (vitPostL1_hasGradAt, vitPostQ_hasGradAt, …, vitPostF1_hasGradAt). Each is a short chain through certified VJPs: the MLP sublayer (mlpSubFlat_tie_v is its backward in the chain's spelling), the out-projection, the full attention layer for LN₁ (mhsaBackFlat_eq_mhsa_vjp).
• The attention core in one of Q, K, V is the new piece. The render's per-head core is a column-slab map with a different function on each head's slab (head h reads K's and V's slab h), so it is Attention's colSlabApplyH, whose Jacobian stays block-diagonal (pdivMat_colIndepH). Each head's VJP is the certified single-head sdpaBack{Q,K,V}, and the lifted backward IS the tie's coreQFlat / coreKFlat / coreVFlat (attnCoreQ_backward, …, all rfl).
• Lifted (HasGradAt.param_batchMapIdx_through, Foundation.Batched.Indexed): read against the linear loss ⟨·, dyₙ⟩ per example, those gradients turn each tied node's Σ_n Σ_j ∂per/∂θ · cotₙ into ∂G/∂θ of the batched block, G the loss at the block's output. Example n's prefix and suffix are at its own drop sites (exampleSite), so the lift is the indexed one; the parameterised op itself is shared. Each node needs the block forward read as "the rest of the block ∘ the node's op ∘ the prefix" (vit_fwd_Wq, …), an equation up to Mat.unflatten_flatten.
• Per net: the loss read after each stage (vitSuf*), pulled back through the certified batched block and head VJPs (vitBlockCotInB_eq_vjp, vitCotTowerOutB_eq_vjp), and each Φ identified with the whole net at updated weights by a standalone vit_factor_* theorem.

Two nodes carry the batch sum inside den, as their text does: the classifier bias (biasGradB) and the CLS token.

Hypotheses. 0 < ε (the LayerNorms' VJPs); no smoothness hypothesis (GELU has no kink). For the smoothed loss, every example's target sums to one and 0 < nC. Stated at ViT-Tiny's literal dims, as the tie is.

Stochastic depth. As in the tie: sd is the render's drop flag, none the drop-free chain, some the *drop* artifacts'. Per example a site is siteScale on the out-projection's or fc2's output (vitHM, vitPostO, vitPostL2/F1/F2), so the loss read after each op runs through it, and the cotangents the bundle states are the tie's at the same sites.

Precision. As in the tie: every per-token dense weight node is rowDenseWeightGradBAt bf16 id … and the patch-embed weight node patchEmbedWeightGradBAt (bf16 && bf16ConvW) id … (StableHLO.PrecisionSwitch), so bf16 := true is the kind the vitin_*bf16 artifacts emit, read over ℝ at the identity rounding (Bf16Erasure), and bf16 := false the f32 artifacts'. The bias, LayerNorm, CLS, position and classifier nodes carry no flag because no render switches them.

The block's forward, per example, as named Mats — blkSaves' let chain verbatim, the attention site in h.

The block forward, read after each node #

Differentiability #