Documentation

LeanMlir.Proofs.Nets.ConvNeXt.ConvNeXtWholeBackCertifiedTieB

convnextInputGradB is the certified whole-net ConvNeXt-T gradient at a batch #

ConvNeXtWholeBackCertifiedTie.lean proves for one image that convnextInputGrad, the reverse of convNextForwardTCh, is the certified gradient at that image. The batched step tie (ConvNeXtStepTieGB.lean) states every activation as StableHLO.batchMap B of the per-example prefix and every cotangent as batchMapAux B of the per-example chain, because channel LayerNorm is per-example and no ConvNeXt op couples examples. This file proves the same at that index: the twelve-stage batched chain convnextInputGradB (ConvNeXtBackChains.lean), every slot the per-example slot lifted at the batched saved activation, is the certified gradient of batchMap B convNextForwardTCh at every batch x, for every B and every class count nC.

The forward is convNextForwardTCh: ConvNeXt-T ([3,3,9,3] at 96→192→384→768), without drop-path, in exact real arithmetic. ConvNeXt is smooth everywhere, so every stage has a global HasVJP and its batched witness is batchMapHasVJPAt over HasVJP.toHasVJPAt at each row. The hypotheses are the 23 LayerNorm positivities the per-example tie carries and no smooth-point condition.

  1. cnxSavedB0 … cnxSavedB10 — the eleven batched stage inputs, as reducible functions of the batch saved stage by stage (batchMap B stage ∘ cnxSavedB_{k-1} B w), not as batchMap B of the composed per-example prefix: the two agree only up to batchMap_comp, not rfl, and the apex's vjpCompDiffAt produces the former. Each is also its apex level's inner map, so the stage witness above it sits at cnxSavedB_k B w x on the nose.
  2. The twelve batched stage witnesses cnx*BAt, each batchMapHasVJPAt over the per-example HasVJP at each row, at the dimension spellings the per-example tie normalised (cnxDn1, cnxLNh, cnxSavedA0).
  3. The batched leaf ties. GAP's is rfl (its per-example tie is); the others are batchMapAux_eq_batchMapHasVJPAt (or its batchMap form for the linear leaves) over the per-example leaf tie at each row. The channel-LN and downsample leaves are proved at variable dims (cnxChanLNBackB_eq_vjp, cnxDownBackB_eq_vjp) and instantiated by term.
  4. convNextForwardTChBHasVJPAt — the twelve-stage apex, eleven vjpCompDiffAts over the batched stage witnesses, level k's inner map named cnxSavedB_k B w — and convnextInputGradB_eq_convNextForwardTChB_vjp, the tie: twelve leaf rewrites, then the eleven levels peeled by rw [vjpCompDiffAt_fst_backward].
  5. convNextForwardTChB_eq_chain — batchMap B of the per-example twelve-factor chain is the twelve batched stages, by batchMap_comp — and convnextInputGradB_eq_batchMap_convNextForwardTCh_vjp, the tie carried to the global witness batchMapHasVJP _ (convNextForwardTChHasVJP …) through HasVJPAt.backward_unique_of_eq, plus the ∑ pdiv reading on convNextForwardTCh itself (convnextInputGradB_correct).
  6. convnextImagenetInputGradB_eq_vjp — the same statement at nC = 1000, B a binder.
@[reducible, inline]
noncomputable abbrev Proofs.cnxSavedB0 (B : ℕ) {nC : ℕ} (w : CnxTWeightsCh nC) :
Vec (B * (3 * 224 * 224)) → Vec (B * (96 * 56 * 56))

The batched stem-conv output — the stem LayerNorm's saved input at every example.

Equations
Instances For
    @[reducible, inline]
    noncomputable abbrev Proofs.cnxSavedB1 (B : ℕ) {nC : ℕ} (w : CnxTWeightsCh nC) :
    Vec (B * (3 * 224 * 224)) → Vec (B * (96 * 56 * 56))

    Stage 1's batched saved input.

    Equations
    Instances For
      @[reducible, inline]
      noncomputable abbrev Proofs.cnxSavedB2 (gf : GeluForm) (B : ℕ) {nC : ℕ} (w : CnxTWeightsCh nC) :
      Vec (B * (3 * 224 * 224)) → Vec (B * (96 * 56 * 56))

      Downsample 1's batched saved input.

      Equations
      Instances For
        @[reducible, inline]
        noncomputable abbrev Proofs.cnxSavedB3 (gf : GeluForm) (B : ℕ) {nC : ℕ} (w : CnxTWeightsCh nC) :
        Vec (B * (3 * 224 * 224)) → Vec (B * (192 * 28 * 28))

        Stage 2's batched saved input.

        Equations
        Instances For
          @[reducible, inline]
          noncomputable abbrev Proofs.cnxSavedB4 (gf : GeluForm) (B : ℕ) {nC : ℕ} (w : CnxTWeightsCh nC) :
          Vec (B * (3 * 224 * 224)) → Vec (B * (192 * 28 * 28))

          Downsample 2's batched saved input.

          Equations
          Instances For
            @[reducible, inline]
            noncomputable abbrev Proofs.cnxSavedB5 (gf : GeluForm) (B : ℕ) {nC : ℕ} (w : CnxTWeightsCh nC) :
            Vec (B * (3 * 224 * 224)) → Vec (B * (384 * 14 * 14))

            Stage 3's batched saved input.

            Equations
            Instances For
              @[reducible, inline]
              noncomputable abbrev Proofs.cnxSavedB6 (gf : GeluForm) (B : ℕ) {nC : ℕ} (w : CnxTWeightsCh nC) :
              Vec (B * (3 * 224 * 224)) → Vec (B * (384 * 14 * 14))

              Downsample 3's batched saved input.

              Equations
              Instances For
                @[reducible, inline]
                noncomputable abbrev Proofs.cnxSavedB7 (gf : GeluForm) (B : ℕ) {nC : ℕ} (w : CnxTWeightsCh nC) :
                Vec (B * (3 * 224 * 224)) → Vec (B * (768 * 7 * 7))

                Stage 4's batched saved input.

                Equations
                Instances For
                  @[reducible, inline]
                  noncomputable abbrev Proofs.cnxSavedB9 (gf : GeluForm) (B : ℕ) {nC : ℕ} (w : CnxTWeightsCh nC) :
                  Vec (B * (3 * 224 * 224)) → Vec (B * 768)

                  The head LayerNorm's batched saved input.

                  Equations
                  Instances For
                    @[reducible, inline]
                    noncomputable abbrev Proofs.cnxSavedB10 (gf : GeluForm) (B : ℕ) {nC : ℕ} (w : CnxTWeightsCh nC) :
                    Vec (B * (3 * 224 * 224)) → Vec (B * 768)

                    The classifier's batched saved input.

                    Equations
                    Instances For
                      noncomputable def Proofs.cnxStemBAt (B : ℕ) {nC : ℕ} (w : CnxTWeightsCh nC) (x : Vec (B * (3 * 224 * 224))) :

                      The batched stem-conv witness at x.

                      Equations
                      Instances For
                        noncomputable def Proofs.cnxChanLNBAt (B c h w : ℕ) (ε : ℝ) (hε : 0 < ε) (γ β : Vec c) (v : Vec (B * (c * h * w))) :

                        The batched channel-LayerNorm witness at v, at any c h w.

                        Equations
                        • One or more equations did not get rendered due to their size.
                        Instances For
                          noncomputable def Proofs.cnxStageBAt (gf : GeluForm) (B : ℕ) {c cExp h w kH kW : ℕ} (k : ℕ) (ps : Fin k → CnxBlockParamsCh c cExp h w kH kW) (hε : ∀ (i : Fin k), 0 < (ps i).εn) (v : Vec (B * (c * h * w))) :

                          The batched depth-k stage witness at v — one definition for all four stages.

                          Equations
                          • One or more equations did not get rendered due to their size.
                          Instances For
                            noncomputable def Proofs.cnxDownBAt (B h w : ℕ) {cin cout : ℕ} (p : CnxDownParamsCh cin cout) (hε : 0 < p.ε) (v : Vec (B * (cin * (2 * h) * (2 * w)))) :

                            The batched downsample witness at v, at any resolution and channel pair.

                            Equations
                            Instances For
                              noncomputable def Proofs.cnxGapBAt (B : ℕ) (v : Vec (B * (768 * 7 * 7))) :

                              The batched GAP witness at v.

                              Equations
                              Instances For
                                noncomputable def Proofs.cnxLNhBAt (B : ℕ) {nC : ℕ} (w : CnxTWeightsCh nC) (hhε : 0 < w.hε) (v : Vec (B * 768)) :

                                The batched head-LayerNorm witness at v.

                                Equations
                                Instances For
                                  noncomputable def Proofs.cnxDenseBAt (B : ℕ) {nC : ℕ} (w : CnxTWeightsCh nC) (v : Vec (B * 768)) :

                                  The batched classifier witness at v.

                                  Equations
                                  Instances For
                                    theorem Proofs.cnxStemBackB_eq_vjp (B : ℕ) {nC : ℕ} (w : CnxTWeightsCh nC) (x : Vec (B * (3 * 224 * 224))) :

                                    The batched stem tie. batchMap B of the reversed-kernel conv at the zero-extended 4×4 kernel IS the lift's backward: flatConvStride4Back_padOdd_eq_vjp_backward at one example's row. padOdd is required here as in the per-example tie: w.sW is 4×4.

                                    theorem Proofs.cnxChanLNBackB_eq_vjp (B c h w : ℕ) (ε : ℝ) (hε : 0 < ε) (γ β : Vec c) (v : Vec (B * (c * h * w))) :
                                    StableHLO.batchMapAux B (chanLNTensor3Back c h w ε γ) v = (cnxChanLNBAt B c h w ε hε γ β v).backward

                                    The batched channel-LayerNorm tie, at any c h w — chanLNTensor3Back_eq_chanLN_vjp at each row. Note: stated at variable dims because an rfl proof at the literal 96 56 56 recursed past maxRecDepth 100000 on the numerals; at variables it is ViT's vitLNBackB_eq_vjp. The stem instance below is a term.

                                    theorem Proofs.cnxStageBackB_eq_vjp {gf : GeluForm} (B : ℕ) {c cExp h w kHd kWd : ℕ} (hkHd : 2 * ((kHd - 1) / 2) + 1 = kHd) (hkWd : 2 * ((kWd - 1) / 2) + 1 = kWd) (k : ℕ) (ps : Fin k → CnxBlockParamsCh c cExp h w kHd kWd) (hε : ∀ (i : Fin k), 0 < (ps i).εn) (v : Vec (B * (c * h * w))) :

                                    The batched stage tie — cnxStageChKBack_eq_vjp at one example's row, for every depth.

                                    theorem Proofs.cnxDownBackB_eq_vjp (B h w : ℕ) {cin cout : ℕ} (p : CnxDownParamsCh cin cout) (hε : 0 < p.ε) (v : Vec (B * (cin * (2 * h) * (2 * w)))) :
                                    StableHLO.batchMapAux B (fun (u : Vec (cin * (2 * h) * (2 * w))) => cnxDownBack (padOdd p.W) (chanLNTensor3Back cin (2 * h) (2 * w) p.ε p.γ u)) v = (cnxDownBAt B h w p hε v).backward

                                    The batched downsample tie, at any resolution — cnxDownChBack_eq_vjp at one example's row. Generic for the same reason as cnxChanLNBackB_eq_vjp; the three instances below are terms at the chain's dimension spellings (cnxDn1 … cnxDn3), which is the per-example tie's cnxDn1Back_eq_vjp … cnxDn3Back_eq_vjp one batch index over. padOdd is required: p.W is 2×2.

                                    theorem Proofs.cnxGapBackB_eq_vjp (B : ℕ) (v : Vec (B * (768 * 7 * 7))) :

                                    The batched GAP tie is rfl, as the per-example gapBack_eq_vjp_backward is.

                                    theorem Proofs.cnxLNhBackB_eq_vjp (B : ℕ) {nC : ℕ} (w : CnxTWeightsCh nC) (hhε : 0 < w.hε) (v : Vec (B * 768)) :

                                    The batched head-LayerNorm tie — cnxLNhBack_eq_vjp at one example's row.

                                    theorem Proofs.cnxDenseBackB_eq_vjp (B : ℕ) {nC : ℕ} (w : CnxTWeightsCh nC) (v : Vec (B * 768)) :

                                    The batched classifier tie — dense_transpose_eq_vjp_backward at one example's row (the head is linear, so the saved v is free).

                                    noncomputable def Proofs.convNextForwardTChBHasVJPAt (gf : GeluForm) (B : ℕ) {nC : ℕ} (w : CnxTWeightsCh nC) (hsε : 0 < w.sε) (h1 : ∀ (i : Fin 3), 0 < (w.s1 i).εn) (hd1 : 0 < w.d1.ε) (h2 : ∀ (i : Fin 3), 0 < (w.s2 i).εn) (hd2 : 0 < w.d2.ε) (h3 : ∀ (i : Fin 9), 0 < (w.s3 i).εn) (hd3 : 0 < w.d3.ε) (h4 : ∀ (i : Fin 3), 0 < (w.s4 i).εn) (hhε : 0 < w.hε) (x : Vec (B * (3 * 224 * 224))) :

                                    The batched whole-net witness, twelve batched stages composed by vjpCompDiffAt, each at the batched saved activation the chain uses (cnxSavedB0 … cnxSavedB10). Level k's inner map is named cnxSavedB_k B w rather than left to the unifier, which would fill it with the composed chain and put every witness at the chain applied to x.

                                    Equations
                                    • One or more equations did not get rendered due to their size.
                                    Instances For
                                      theorem Proofs.convnextInputGradB_eq_convNextForwardTChB_vjp {gf : GeluForm} (B : ℕ) {nC : ℕ} (w : CnxTWeightsCh nC) (hsε : 0 < w.sε) (h1 : ∀ (i : Fin 3), 0 < (w.s1 i).εn) (hd1 : 0 < w.d1.ε) (h2 : ∀ (i : Fin 3), 0 < (w.s2 i).εn) (hd2 : 0 < w.d2.ε) (h3 : ∀ (i : Fin 9), 0 < (w.s3 i).εn) (hd3 : 0 < w.d3.ε) (h4 : ∀ (i : Fin 3), 0 < (w.s4 i).εn) (hhε : 0 < w.hε) (x : Vec (B * (3 * 224 * 224))) :
                                      convnextInputGradB B w.Wd (padOdd w.sW) (chanLNTensor3Back 96 56 56 w.sε w.sγ) (cnxSavedB0 B w x) (rowLNVecFlatBack 1 768 w.hε w.hγ) (cnxSavedB9 gf B w x) (cnxStageChKBack gf 3 w.s1) (cnxSavedB1 B w x) (fun (u : Vec (96 * 56 * 56)) => cnxDownBack (padOdd w.d1.W) (chanLNTensor3Back 96 56 56 w.d1.ε w.d1.γ u)) (cnxSavedB2 gf B w x) (cnxStageChKBack gf 3 w.s2) (cnxSavedB3 gf B w x) (fun (u : Vec (192 * 28 * 28)) => cnxDownBack (padOdd w.d2.W) (chanLNTensor3Back 192 28 28 w.d2.ε w.d2.γ u)) (cnxSavedB4 gf B w x) (cnxStageChKBack gf 9 w.s3) (cnxSavedB5 gf B w x) (fun (u : Vec (384 * 14 * 14)) => cnxDownBack (padOdd w.d3.W) (chanLNTensor3Back 384 14 14 w.d3.ε w.d3.γ u)) (cnxSavedB6 gf B w x) (cnxStageChKBack gf 3 w.s4) (cnxSavedB7 gf B w x) = (convNextForwardTChBHasVJPAt gf B w hsε h1 hd1 h2 hd2 h3 hd3 h4 hhε x).backward

                                      The batched tie. convnextInputGradB with every slot the per-example slot at the batched saved activation is the backward of convNextForwardTChBHasVJPAt, at every B, nC and batch x, under the 23 LayerNorm positivities.

                                      The shape check. batchMap B of the per-example twelve-factor chain — the function convNextForwardTChHasVJP is stated on — IS the twelve batched stages the apex is stated on: batchMap_comp eleven times, and the normalised spellings (cnxLNh, cnxDn1 … cnxDn3, cnxSavedA0) unfold to the chain's.

                                      theorem Proofs.convnextInputGradB_eq_batchMap_convNextForwardTCh_vjp {gf : GeluForm} (B : ℕ) {nC : ℕ} (w : CnxTWeightsCh nC) (hsε : 0 < w.sε) (h1 : ∀ (i : Fin 3), 0 < (w.s1 i).εn) (hd1 : 0 < w.d1.ε) (h2 : ∀ (i : Fin 3), 0 < (w.s2 i).εn) (hd2 : 0 < w.d2.ε) (h3 : ∀ (i : Fin 9), 0 < (w.s3 i).εn) (hd3 : 0 < w.d3.ε) (h4 : ∀ (i : Fin 3), 0 < (w.s4 i).εn) (hhε : 0 < w.hε) (x : Vec (B * (3 * 224 * 224))) :
                                      convnextInputGradB B w.Wd (padOdd w.sW) (chanLNTensor3Back 96 56 56 w.sε w.sγ) (cnxSavedB0 B w x) (rowLNVecFlatBack 1 768 w.hε w.hγ) (cnxSavedB9 gf B w x) (cnxStageChKBack gf 3 w.s1) (cnxSavedB1 B w x) (fun (u : Vec (96 * 56 * 56)) => cnxDownBack (padOdd w.d1.W) (chanLNTensor3Back 96 56 56 w.d1.ε w.d1.γ u)) (cnxSavedB2 gf B w x) (cnxStageChKBack gf 3 w.s2) (cnxSavedB3 gf B w x) (fun (u : Vec (192 * 28 * 28)) => cnxDownBack (padOdd w.d2.W) (chanLNTensor3Back 192 28 28 w.d2.ε w.d2.γ u)) (cnxSavedB4 gf B w x) (cnxStageChKBack gf 9 w.s3) (cnxSavedB5 gf B w x) (fun (u : Vec (384 * 14 * 14)) => cnxDownBack (padOdd w.d3.W) (chanLNTensor3Back 384 14 14 w.d3.ε w.d3.γ u)) (cnxSavedB6 gf B w x) (cnxStageChKBack gf 3 w.s4) (cnxSavedB7 gf B w x) = (batchMapHasVJP (dense w.Wd w.bd ∘ rowLNVecFlat 1 768 w.hε w.hγ w.hβ ∘ globalAvgPoolFlat 768 7 7 ∘ convNextStageChK gf 3 w.s4 ∘ cnxDownChW 7 7 w.d3 ∘ convNextStageChK gf 9 w.s3 ∘ cnxDownChW 14 14 w.d2 ∘ convNextStageChK gf 3 w.s2 ∘ cnxDownChW 28 28 w.d1 ∘ convNextStageChK gf 3 w.s1 ∘ chanLNTensor3 96 56 56 w.sε w.sγ w.sβ ∘ flatConvStride4 w.sW w.sb) (convNextForwardTChHasVJP gf w hsε h1 hd1 h2 hd2 h3 hd3 h4 hhε) ⋯).backward x

                                      The batched apex at the global witness. convnextInputGradB is (batchMapHasVJP _ (convNextForwardTChHasVJP …) …).backward x — the certified gradient of the drop-free per-example ConvNeXt-T forward lifted over B examples, for every B, every nC and every batch x. The hypotheses are the 23 LayerNorm positivities. Carried from the chain-shaped apex by HasVJPAt.backward_unique_of_eq along convNextForwardTChB_eq_chain.

                                      theorem Proofs.convnextInputGradB_correct {gf : GeluForm} (B : ℕ) {nC : ℕ} (w : CnxTWeightsCh nC) (hsε : 0 < w.sε) (h1 : ∀ (i : Fin 3), 0 < (w.s1 i).εn) (hd1 : 0 < w.d1.ε) (h2 : ∀ (i : Fin 3), 0 < (w.s2 i).εn) (hd2 : 0 < w.d2.ε) (h3 : ∀ (i : Fin 9), 0 < (w.s3 i).εn) (hd3 : 0 < w.d3.ε) (h4 : ∀ (i : Fin 3), 0 < (w.s4 i).εn) (hhε : 0 < w.hε) (x : Vec (B * (3 * 224 * 224))) (dy : Vec (B * nC)) (i : Fin (B * (3 * 224 * 224))) :
                                      convnextInputGradB B w.Wd (padOdd w.sW) (chanLNTensor3Back 96 56 56 w.sε w.sγ) (cnxSavedB0 B w x) (rowLNVecFlatBack 1 768 w.hε w.hγ) (cnxSavedB9 gf B w x) (cnxStageChKBack gf 3 w.s1) (cnxSavedB1 B w x) (fun (u : Vec (96 * 56 * 56)) => cnxDownBack (padOdd w.d1.W) (chanLNTensor3Back 96 56 56 w.d1.ε w.d1.γ u)) (cnxSavedB2 gf B w x) (cnxStageChKBack gf 3 w.s2) (cnxSavedB3 gf B w x) (fun (u : Vec (192 * 28 * 28)) => cnxDownBack (padOdd w.d2.W) (chanLNTensor3Back 192 28 28 w.d2.ε w.d2.γ u)) (cnxSavedB4 gf B w x) (cnxStageChKBack gf 9 w.s3) (cnxSavedB5 gf B w x) (fun (u : Vec (384 * 14 * 14)) => cnxDownBack (padOdd w.d3.W) (chanLNTensor3Back 384 14 14 w.d3.ε w.d3.γ u)) (cnxSavedB6 gf B w x) (cnxStageChKBack gf 3 w.s4) (cnxSavedB7 gf B w x) dy i = ∑ j : Fin (B * nC), pdiv (StableHLO.batchMap B (convNextForwardTCh gf w)) x i j * dy j

                                      The batched apex, read as the Jacobian of the committed forward. convnextInputGradB is the pdiv-contracted Jacobian transpose of batchMap B (convNextForwardTCh w) — the nested-application forward the graph faithfulness convNextFwdGraphTCh_faithful is about — at EVERY batch and EVERY cotangent, through convNextForwardTCh_eq_chain.

                                      theorem Proofs.convnextImagenetInputGradB_eq_vjp {gf : GeluForm} (B : ℕ) (w : CnxTWeightsCh 1000) (hsε : 0 < w.sε) (h1 : ∀ (i : Fin 3), 0 < (w.s1 i).εn) (hd1 : 0 < w.d1.ε) (h2 : ∀ (i : Fin 3), 0 < (w.s2 i).εn) (hd2 : 0 < w.d2.ε) (h3 : ∀ (i : Fin 9), 0 < (w.s3 i).εn) (hd3 : 0 < w.d3.ε) (h4 : ∀ (i : Fin 3), 0 < (w.s4 i).εn) (hhε : 0 < w.hε) (x : Vec (B * (3 * 224 * 224))) :
                                      convnextInputGradB B w.Wd (padOdd w.sW) (chanLNTensor3Back 96 56 56 w.sε w.sγ) (cnxSavedB0 B w x) (rowLNVecFlatBack 1 768 w.hε w.hγ) (cnxSavedB9 gf B w x) (cnxStageChKBack gf 3 w.s1) (cnxSavedB1 B w x) (fun (u : Vec (96 * 56 * 56)) => cnxDownBack (padOdd w.d1.W) (chanLNTensor3Back 96 56 56 w.d1.ε w.d1.γ u)) (cnxSavedB2 gf B w x) (cnxStageChKBack gf 3 w.s2) (cnxSavedB3 gf B w x) (fun (u : Vec (192 * 28 * 28)) => cnxDownBack (padOdd w.d2.W) (chanLNTensor3Back 192 28 28 w.d2.ε w.d2.γ u)) (cnxSavedB4 gf B w x) (cnxStageChKBack gf 9 w.s3) (cnxSavedB5 gf B w x) (fun (u : Vec (384 * 14 * 14)) => cnxDownBack (padOdd w.d3.W) (chanLNTensor3Back 384 14 14 w.d3.ε w.d3.γ u)) (cnxSavedB6 gf B w x) (cnxStageChKBack gf 3 w.s4) (cnxSavedB7 gf B w x) = (batchMapHasVJP (dense w.Wd w.bd ∘ rowLNVecFlat 1 768 w.hε w.hγ w.hβ ∘ globalAvgPoolFlat 768 7 7 ∘ convNextStageChK gf 3 w.s4 ∘ cnxDownChW 7 7 w.d3 ∘ convNextStageChK gf 9 w.s3 ∘ cnxDownChW 14 14 w.d2 ∘ convNextStageChK gf 3 w.s2 ∘ cnxDownChW 28 28 w.d1 ∘ convNextStageChK gf 3 w.s1 ∘ chanLNTensor3 96 56 56 w.sε w.sγ w.sβ ∘ flatConvStride4 w.sW w.sb) (convNextForwardTChHasVJP gf w hsε h1 hd1 h2 hd2 h3 hd3 h4 hhε) ⋯).backward x

                                      ConvNeXt-T's batched whole-net backward tie at the ImageNet head. convnextInputGradB_eq_batchMap_convNextForwardTCh_vjp at nC = 1000, the class count of the convnextin_* (ConvNeXt-T) artifacts, at a variable batch B (64 per device in those artifacts). The dims are ConvNeXt-T's (3×224², [3,3,9,3] at 96→192→384→768). The forward is the drop-free convNextForwardTCh in exact arithmetic: the drop-path (*drop*) artifacts and ConvNeXt-S/B (convnextsin_*, convnextbin_*) compute other functions and are not covered. The batched peers of the other nets are r34InputGradB_eq_r34B_full_vjp, mnv2InputGradB_eq_mobilenetv2B_full_vjp and vitTinyInputGradB_eq_vitTiny_vjp.