Documentation

LeanMlir.Proofs.Nets.MobileNet.MobileNetV4SyncB

MobileNetV4-Conv-M's data-parallel forward at SYNCHRONISED BatchNorm — replica r IS shard r #

MobileNetV4FullB.lean (T2) says the typed batch-BN graph denotes mobilenetv4ForwardB_full N w on one device. MobileNetV4RenderB's data-parallel step normalises with the GLOBAL batch's statistics at replicas > 1: every one of the 77 BatchNorm sites is the sync-BN composition — this replica's mean all-reduced, then Chan's σ²_r + (μ_r − μ)² all-reduced, packed, then bnSyncF. This file is T2's data-parallel twin: that forward graph, stated as a family over the R replicas, denotes on replica r exactly batchShard r of the single-device forward at the global batch R·N.

den (mnv4FwdGraphSync_full R hR N epsStr w e r)
  = batchShard R N nCls (mobilenetv4ForwardB_full (R * N) w X) r

given that each replica's input is its shard of one global batch X. ⭐ The spec does not move: the right-hand side is the committed mobilenetv4ForwardB_full, at N := R·N.

How it is proved #

As ResNet34SyncB.lean and MobileNetV2SyncB.lean prove theirs: one block at a time, with the shard hypothesis ∀ r, den (e r) = batchShard R N _ X r carried from block to block.

Same shape as T2, and for T2's reasons. The block lemmas are GENERIC IN THE ROW (s : UibSpec), so every width is a projection of a variable and nothing evaluates; each one closes on the row-typed mnv4BodyOfRow (R * N) s p / mnv4PreStridedBodyOfRow by the dispatch hypotheses T2 uses (s.preDWk ≠ 0, s.postDWk = 0, …), discharged by decide at the concrete rows. The skip is one generic combinator (mnv4SkipGraphSync, the peer of mnv4SkipGraphB), which keeps the whole-net term linear in the depth. The five resolution groups are proved against mnv4Res*Layer (R * N) w through T2's _fwd_apply peels, and the whole net is a have-chain of eight stage lemmas over mobilenetv4ForwardB_full's own prefixes — no CertLayer.comp is ever peeled at a literal width.

The index seam #

The conv/relu chain runs at the left-assoc index N·(c·h·w); bnSyncF and its statistics nodes at N·(c·(h·w)). As in ResNet-34's and MobileNetV2's twins the site is ResNet34SyncB's bnSyncSiteLA, which carries the mul_assoc relabelling as castIdx on the AST value (the emitted text does not change: skel never sees an index), and den_bnSyncSiteLA reads P1 back at the network index through batchShard_castIdx. Nothing about the seam is MobileNetV4's own.

Names #

Parameter names are MobileNetV4FullB's, read off the row (%u{p}{q,e,d,p}{W,g,bt}, %f0cW, %sW, %h1W, %hW, …), and every bias operand is the shared zero %zb{c}. A BatchNorm site with γ %u{p}qg gathers its statistics as %arsum / %armean of u{p}qgmu and u{p}qgvar, each over a [c] vector — the γ name without %, then mu / var, the tag bnFwdSite is handed.

What is NOT claimed here #

⚠ The backward and the parameter collectives are the T3 half (MobileNetV4SyncStepTieB.lean). ⚠ Every conv here is bias-free by construction: MobileNetV4RenderB has no convBias flag and binds each bias slot to the zero %zb{c}, so no bias is trained and no bias gradient is emitted (the statement is ∀ w, and zero biases are one instance). ⚠ The statement is at the f32 nodes; the *bf16 artifact's bf16 conv twins are outside it. ⚠ That the R replicas' inputs ARE the shards of one batch is the driver's, as in DataParallelSync.lean. ⚠ The lowerer's all_reduce is trusted as every other op's lowering is.

theorem Proofs.StableHLO.den_swish_shard {R N n : } (e : Fin RSHlo (N * n)) (X : Vec (R * N * n)) (he : ∀ (r : Fin R), den (e r) = batchShard R N n X r) (r : Fin R) :
den (SHlo.batchOp BatchableOp.swish (e r)) = batchShard R N n (swish (R * N * n) X) r

swish on every replica is the shard of the global swish — the fused stage's activation, read cell by cell. The peer of den_relu_shard, stated at the whole-batch swish the committed forward (fusedConvB) is written in.

def Proofs.StableHLO.mnv4StemGraphSync (epsStr : String) (R : ) (hR : 0 < R) (N h w : ) {ic oc kH kW : } (Ws : Kernel4 oc ic kH kW) (bs : Vec oc) (εs : ) (γs βs : Vec oc) (e : Fin RSHlo (N * (ic * (2 * h) * (2 * w)))) :
Fin RSHlo (N * (oc * h * w))

Stem at sync-BN, over the replica family: 3×3/s2 XLA-SAME conv → sync-BN → relu.

Equations
  • One or more equations did not get rendered due to their size.
Instances For
    theorem Proofs.StableHLO.mnv4StemGraphSync_shard (epsStr : String) (R : ) (hR : 0 < R) (N h w : ) {ic oc kH kW : } (hN : 0 < N) (hh : 0 < h) (hw : 0 < w) (Ws : Kernel4 oc ic kH kW) (bs : Vec oc) (εs : ) (γs βs : Vec oc) (e : Fin RSHlo (N * (ic * (2 * h) * (2 * w)))) (X : Vec (R * N * (ic * (2 * h) * (2 * w)))) (he : ∀ (r : Fin R), den (e r) = batchShard R N (ic * (2 * h) * (2 * w)) X r) (r : Fin R) :
    den (mnv4StemGraphSync epsStr R hR N h w Ws bs εs γs βs e r) = batchShard R N (oc * h * w) (mnv4StemB (R * N) h w Ws bs εs γs βs X) r
    def Proofs.StableHLO.mnv4FusedGraphSync (epsStr : String) (R : ) (hR : 0 < R) (N h w : ) {ic mid oc kH kW : } (Wc : Kernel4 mid ic kH kW) (bc : Vec mid) (εc : ) (γc βc : Vec mid) (Wp : Kernel4 oc mid 1 1) (bp : Vec oc) (εp : ) (γp βp : Vec oc) (e : Fin RSHlo (N * (ic * (2 * h) * (2 * w)))) :
    Fin RSHlo (N * (oc * h * w))

    Fused stage at sync-BN, over the replica family: 3×3/s2 SYMMETRIC conv → sync-BN → swish → 1×1 project → sync-BN. Two sync sites, no skip.

    Equations
    • One or more equations did not get rendered due to their size.
    Instances For
      theorem Proofs.StableHLO.mnv4FusedGraphSync_shard (epsStr : String) (R : ) (hR : 0 < R) (N h w : ) {ic mid oc kH kW : } (hN : 0 < N) (hh : 0 < h) (hw : 0 < w) (Wc : Kernel4 mid ic kH kW) (bc : Vec mid) (εc : ) (hεc : 0 < εc) (γc βc : Vec mid) (Wp : Kernel4 oc mid 1 1) (bp : Vec oc) (εp : ) (hεp : 0 < εp) (γp βp : Vec oc) (e : Fin RSHlo (N * (ic * (2 * h) * (2 * w)))) (X : Vec (R * N * (ic * (2 * h) * (2 * w)))) (he : ∀ (r : Fin R), den (e r) = batchShard R N (ic * (2 * h) * (2 * w)) X r) (r : Fin R) :
      den (mnv4FusedGraphSync epsStr R hR N h w Wc bc εc γc βc Wp bp εp γp βp e r) = batchShard R N (oc * h * w) ((mnv4FusedStage (R * N) (mnv4FusedConvLayer (R * N) Wc bc εc hεc γc βc) (projLayer (R * N) Wp bp εp hεp γp βp)).fwd X) r
      def Proofs.StableHLO.mnv4ExtraDWBodyGraphSync (epsStr : String) (R : ) (hR : 0 < R) (N : ) (s : UibSpec) (p : UibParams s) (e : Fin RSHlo (N * (s.ic * s.h * s.h))) :
      Fin RSHlo (N * (s.oc * s.h * s.h))

      ExtraDW body at sync-BN, over the replica family — both depthwises present: pre-DW → sync-BN → relu → expand → sync-BN → relu → post-DW → sync-BN → relu → project → sync-BN. Four sync sites. The body only; the identity skip is mnv4SkipGraphSync.

      Equations
      • One or more equations did not get rendered due to their size.
      Instances For
        theorem Proofs.StableHLO.mnv4ExtraDWBodyGraphSync_shard (epsStr : String) (R : ) (hR : 0 < R) (N : ) (hN : 0 < N) (s : UibSpec) (hh : 0 < s.h) (p : UibParams s) (hq : s.preDWk 0) (hd : s.postDWk 0) (e : Fin RSHlo (N * (s.ic * s.h * s.h))) (X : Vec (R * N * (s.ic * s.h * s.h))) (he : ∀ (r : Fin R), den (e r) = batchShard R N (s.ic * s.h * s.h) X r) (r : Fin R) :
        den (mnv4ExtraDWBodyGraphSync epsStr R hR N s p e r) = batchShard R N (s.oc * s.h * s.h) ((mnv4BodyOfRow (R * N) s p).fwd X) r

        ⭐ The ExtraDW body at sync-BN is shard r of the row-typed body at R·N — generic in the row, the dispatch hypotheses T2's mnv4ExtraDWBodyGraphB_faithful takes.

        def Proofs.StableHLO.mnv4ConvNeXtBodyGraphSync (epsStr : String) (R : ) (hR : 0 < R) (N : ) (s : UibSpec) (p : UibParams s) (e : Fin RSHlo (N * (s.ic * s.h * s.h))) :
        Fin RSHlo (N * (s.oc * s.h * s.h))

        ConvNeXt-like body at sync-BN — pre-DW only (postDWk = 0): the absent depthwise emits no tokens, exactly as in T2. Three sync sites.

        Equations
        • One or more equations did not get rendered due to their size.
        Instances For
          theorem Proofs.StableHLO.mnv4ConvNeXtBodyGraphSync_shard (epsStr : String) (R : ) (hR : 0 < R) (N : ) (hN : 0 < N) (s : UibSpec) (hh : 0 < s.h) (p : UibParams s) (hq : s.preDWk 0) (hd : s.postDWk = 0) (e : Fin RSHlo (N * (s.ic * s.h * s.h))) (X : Vec (R * N * (s.ic * s.h * s.h))) (he : ∀ (r : Fin R), den (e r) = batchShard R N (s.ic * s.h * s.h) X r) (r : Fin R) :
          den (mnv4ConvNeXtBodyGraphSync epsStr R hR N s p e r) = batchShard R N (s.oc * s.h * s.h) ((mnv4BodyOfRow (R * N) s p).fwd X) r
          def Proofs.StableHLO.mnv4FfnBodyGraphSync (epsStr : String) (R : ) (hR : 0 < R) (N : ) (s : UibSpec) (p : UibParams s) (e : Fin RSHlo (N * (s.ic * s.h * s.h))) :
          Fin RSHlo (N * (s.oc * s.h * s.h))

          FFN body at sync-BN — neither depthwise: expand → sync-BN → relu → project → sync-BN.

          Equations
          • One or more equations did not get rendered due to their size.
          Instances For
            theorem Proofs.StableHLO.mnv4FfnBodyGraphSync_shard (epsStr : String) (R : ) (hR : 0 < R) (N : ) (hN : 0 < N) (s : UibSpec) (hh : 0 < s.h) (p : UibParams s) (hq : s.preDWk = 0) (hd : s.postDWk = 0) (e : Fin RSHlo (N * (s.ic * s.h * s.h))) (X : Vec (R * N * (s.ic * s.h * s.h))) (he : ∀ (r : Fin R), den (e r) = batchShard R N (s.ic * s.h * s.h) X r) (r : Fin R) :
            den (mnv4FfnBodyGraphSync epsStr R hR N s p e r) = batchShard R N (s.oc * s.h * s.h) ((mnv4BodyOfRow (R * N) s p).fwd X) r
            def Proofs.StableHLO.mnv4PreStridedGraphSync (epsStr : String) (R : ) (hR : 0 < R) (N : ) (s : UibSpec) (p : UibParams s) (e : Fin RSHlo (N * (s.ic * (2 * s.h) * (2 * s.h)))) :
            Fin RSHlo (N * (s.oc * s.h * s.h))

            Pre-strided block at sync-BN — rows 1, 3 and 11: the leading depthwise carries the stride (.depthwiseStrided, SYMMETRIC padding), everything after it at the reduced h. Four sync sites; no skip (ic ≠ oc).

            Equations
            • One or more equations did not get rendered due to their size.
            Instances For
              theorem Proofs.StableHLO.mnv4PreStridedGraphSync_shard (epsStr : String) (R : ) (hR : 0 < R) (N : ) (hN : 0 < N) (s : UibSpec) (hh : 0 < s.h) (p : UibParams s) (hd : s.postDWk 0) (e : Fin RSHlo (N * (s.ic * (2 * s.h) * (2 * s.h)))) (X : Vec (R * N * (s.ic * (2 * s.h) * (2 * s.h)))) (he : ∀ (r : Fin R), den (e r) = batchShard R N (s.ic * (2 * s.h) * (2 * s.h)) X r) (r : Fin R) :
              den (mnv4PreStridedGraphSync epsStr R hR N s p e r) = batchShard R N (s.oc * s.h * s.h) ((mnv4PreStridedBodyOfRow (R * N) s p).fwd X) r
              def Proofs.StableHLO.mnv4SkipGraphSync {R N n : } (body : (Fin RSHlo (N * n))Fin RSHlo (N * n)) (e : Fin RSHlo (N * n)) :
              Fin RSHlo (N * n)

              One skip row at sync-BN: its body's family, plus the identity skip, replica by replica — the peer of mnv4SkipGraphB, and a named combinator for the same reason: the add needs the block's input family twice, and kept folded the whole-net term stays linear in the depth.

              Equations
              Instances For
                theorem Proofs.StableHLO.mnv4SkipGraphSync_shard {R N n : } (body : (Fin RSHlo (N * n))Fin RSHlo (N * n)) (f : Vec (R * N * n)Vec (R * N * n)) (hb : ∀ (e' : Fin RSHlo (N * n)) (X' : Vec (R * N * n)), (∀ (r : Fin R), den (e' r) = batchShard R N n X' r)∀ (r : Fin R), den (body e' r) = batchShard R N n (f X') r) (e : Fin RSHlo (N * n)) (X : Vec (R * N * n)) (he : ∀ (r : Fin R), den (e r) = batchShard R N n X r) (r : Fin R) :
                den (mnv4SkipGraphSync body e r) = batchShard R N n (residual f X) r

                A skip row at sync-BN is shard r of residual of whatever its body shards to — generic in the body, so one lemma serves all eighteen and the body's shard lemma is the only input.

                def Proofs.StableHLO.mnv4HeadGraphSync (epsStr : String) (R : ) (hR : 0 < R) (N h w : ) {c mid oc nCls : } (W1 : Kernel4 mid c 1 1) (b1 : Vec mid) (ε1 : ) (γ1 β1 : Vec mid) (W2 : Kernel4 oc mid 1 1) (b2 : Vec oc) (ε2 : ) (γ2 β2 : Vec oc) (Wd : Mat oc nCls) (bd : Vec nCls) (e : Fin RSHlo (N * (c * h * w))) :
                Fin RSHlo (N * nCls)

                Head at sync-BN, over the replica family: 1×1 conv → sync-BN → relu, a SECOND 1×1 conv → sync-BN → relu, GAP, dense — Conv-M's two head convs.

                Equations
                • One or more equations did not get rendered due to their size.
                Instances For
                  theorem Proofs.StableHLO.mnv4HeadGraphSync_shard (epsStr : String) (R : ) (hR : 0 < R) (N h w : ) {c mid oc nCls : } (hN : 0 < N) (hh : 0 < h) (hw : 0 < w) (W1 : Kernel4 mid c 1 1) (b1 : Vec mid) (ε1 : ) (hε1 : 0 < ε1) (γ1 β1 : Vec mid) (W2 : Kernel4 oc mid 1 1) (b2 : Vec oc) (ε2 : ) (hε2 : 0 < ε2) (γ2 β2 : Vec oc) (Wd : Mat oc nCls) (bd : Vec nCls) (e : Fin RSHlo (N * (c * h * w))) (X : Vec (R * N * (c * h * w))) (he : ∀ (r : Fin R), den (e r) = batchShard R N (c * h * w) X r) (r : Fin R) :
                  den (mnv4HeadGraphSync epsStr R hR N h w W1 b1 ε1 γ1 β1 W2 b2 ε2 γ2 β2 Wd bd e r) = batchShard R N nCls (((cbReluLayer (R * N) W1 b1 ε1 hε1 γ1 β1).comp (mnv4Head (R * N) (cbReluLayer (R * N) W2 b2 ε2 hε2 γ2 β2) (mnv4GapLayer (R * N)) (mnv4DenseLayer (R * N) Wd bd))).fwd X) r
                  def Proofs.StableHLO.mnv4Res28GraphSync (R : ) (hR : 0 < R) (N : ) (epsStr : String) {nCls : } (w : Mnv4BWeights nCls) (e : Fin RSHlo (N * (48 * 56 * 56))) :
                  Fin RSHlo (N * (80 * 28 * 28))

                  Trunk group Res28 at sync-BN — rows 1–2.

                  Equations
                  • One or more equations did not get rendered due to their size.
                  Instances For
                    theorem Proofs.StableHLO.mnv4Res28GraphSync_shard (R : ) (hR : 0 < R) (N : ) (hN : 0 < N) (epsStr : String) {nCls : } (w : Mnv4BWeights nCls) (e : Fin RSHlo (N * (48 * 56 * 56))) (X : Vec (R * N * (48 * 56 * 56))) (he : ∀ (r : Fin R), den (e r) = batchShard R N (48 * 56 * 56) X r) (r : Fin R) :
                    den (mnv4Res28GraphSync R hR N epsStr w e r) = batchShard R N (80 * 28 * 28) ((mnv4Res28Layer (R * N) w).fwd X) r
                    def Proofs.StableHLO.mnv4Res14aGraphSync (R : ) (hR : 0 < R) (N : ) (epsStr : String) {nCls : } (w : Mnv4BWeights nCls) (e : Fin RSHlo (N * (80 * 28 * 28))) :
                    Fin RSHlo (N * (160 * 14 * 14))

                    Trunk group Res14a at sync-BN — rows 3–6.

                    Equations
                    • One or more equations did not get rendered due to their size.
                    Instances For
                      theorem Proofs.StableHLO.mnv4Res14aGraphSync_shard (R : ) (hR : 0 < R) (N : ) (hN : 0 < N) (epsStr : String) {nCls : } (w : Mnv4BWeights nCls) (e : Fin RSHlo (N * (80 * 28 * 28))) (X : Vec (R * N * (80 * 28 * 28))) (he : ∀ (r : Fin R), den (e r) = batchShard R N (80 * 28 * 28) X r) (r : Fin R) :
                      den (mnv4Res14aGraphSync R hR N epsStr w e r) = batchShard R N (160 * 14 * 14) ((mnv4Res14aLayer (R * N) w).fwd X) r
                      def Proofs.StableHLO.mnv4Res14bGraphSync (R : ) (hR : 0 < R) (N : ) (epsStr : String) {nCls : } (w : Mnv4BWeights nCls) (e : Fin RSHlo (N * (160 * 14 * 14))) :
                      Fin RSHlo (N * (160 * 14 * 14))

                      Trunk group Res14b at sync-BN — rows 7–10: ExtraDW, ConvNeXt, FFN, ConvNeXt.

                      Equations
                      • One or more equations did not get rendered due to their size.
                      Instances For
                        theorem Proofs.StableHLO.mnv4Res14bGraphSync_shard (R : ) (hR : 0 < R) (N : ) (hN : 0 < N) (epsStr : String) {nCls : } (w : Mnv4BWeights nCls) (e : Fin RSHlo (N * (160 * 14 * 14))) (X : Vec (R * N * (160 * 14 * 14))) (he : ∀ (r : Fin R), den (e r) = batchShard R N (160 * 14 * 14) X r) (r : Fin R) :
                        den (mnv4Res14bGraphSync R hR N epsStr w e r) = batchShard R N (160 * 14 * 14) ((mnv4Res14bLayer (R * N) w).fwd X) r
                        def Proofs.StableHLO.mnv4Res7aGraphSync (R : ) (hR : 0 < R) (N : ) (epsStr : String) {nCls : } (w : Mnv4BWeights nCls) (e : Fin RSHlo (N * (160 * 14 * 14))) :
                        Fin RSHlo (N * (256 * 7 * 7))

                        Trunk group Res7a at sync-BN — rows 11–15.

                        Equations
                        • One or more equations did not get rendered due to their size.
                        Instances For
                          theorem Proofs.StableHLO.mnv4Res7aGraphSync_shard (R : ) (hR : 0 < R) (N : ) (hN : 0 < N) (epsStr : String) {nCls : } (w : Mnv4BWeights nCls) (e : Fin RSHlo (N * (160 * 14 * 14))) (X : Vec (R * N * (160 * 14 * 14))) (he : ∀ (r : Fin R), den (e r) = batchShard R N (160 * 14 * 14) X r) (r : Fin R) :
                          den (mnv4Res7aGraphSync R hR N epsStr w e r) = batchShard R N (256 * 7 * 7) ((mnv4Res7aLayer (R * N) w).fwd X) r
                          def Proofs.StableHLO.mnv4Res7bGraphSync (R : ) (hR : 0 < R) (N : ) (epsStr : String) {nCls : } (w : Mnv4BWeights nCls) (e : Fin RSHlo (N * (256 * 7 * 7))) :
                          Fin RSHlo (N * (256 * 7 * 7))

                          Trunk group Res7b at sync-BN — rows 16–21.

                          Equations
                          • One or more equations did not get rendered due to their size.
                          Instances For
                            theorem Proofs.StableHLO.mnv4Res7bGraphSync_shard (R : ) (hR : 0 < R) (N : ) (hN : 0 < N) (epsStr : String) {nCls : } (w : Mnv4BWeights nCls) (e : Fin RSHlo (N * (256 * 7 * 7))) (X : Vec (R * N * (256 * 7 * 7))) (he : ∀ (r : Fin R), den (e r) = batchShard R N (256 * 7 * 7) X r) (r : Fin R) :
                            den (mnv4Res7bGraphSync R hR N epsStr w e r) = batchShard R N (256 * 7 * 7) ((mnv4Res7bLayer (R * N) w).fwd X) r
                            theorem Proofs.StableHLO.mnv4FusedStack_graphSync_shard (R : ) (hR : 0 < R) (N : ) (hN : 0 < N) (epsStr : String) {nCls : } (w : Mnv4BWeights nCls) (e : Fin RSHlo (N * (32 * 112 * 112))) (X : Vec (R * N * (32 * 112 * 112))) (he : ∀ (r : Fin R), den (e r) = batchShard R N (32 * 112 * 112) X r) (r : Fin R) :
                            den (mnv4FusedGraphSync epsStr R hR N 56 56 w.f0cW w.f0cb w.f0cE w.f0cg w.f0cbt w.f0pW w.f0pb w.f0pE w.f0pg w.f0pbt e r) = batchShard R N (48 * 56 * 56) ((mnv4FusedStack (R * N) w).fwd X) r

                            The fused stage's shard lemma, restated at mnv4FusedStack (R * N) w — so the whole-net proof never unfolds the stack, for the reason mnv4FusedStack_graph_faithful records.

                            theorem Proofs.StableHLO.mnv4HeadStack_graphSync_shard (R : ) (hR : 0 < R) (N : ) (hN : 0 < N) (epsStr : String) {nCls : } (w : Mnv4BWeights nCls) (e : Fin RSHlo (N * (256 * 7 * 7))) (X : Vec (R * N * (256 * 7 * 7))) (he : ∀ (r : Fin R), den (e r) = batchShard R N (256 * 7 * 7) X r) (r : Fin R) :
                            den (mnv4HeadGraphSync epsStr R hR N 7 7 w.h1W w.h1b w.h1E w.h1g w.h1bt w.hW w.hb w.hE w.hg w.hbt w.Wd w.bd e r) = batchShard R N nCls ((mnv4HeadStack (R * N) w).fwd X) r

                            The head's, restated at mnv4HeadStack (R * N) w. Same reason.

                            def Proofs.StableHLO.mnv4FwdGraphSync_full (R : ) (hR : 0 < R) (N : ) (epsStr : String) {nCls : } (w : Mnv4BWeights nCls) (e : Fin RSHlo (N * (3 * 224 * 224))) :
                            Fin RSHlo (N * nCls)

                            The sync-BN data-parallel MobileNetV4-Conv-M forward graph, over the replica family. T2's mnv4FwdGraphB_full with every one of its 77 BatchNorms a bnSyncSiteLA over all R replicas; parameter names are read off the rows and collective tags are the render's.

                            Equations
                            • One or more equations did not get rendered due to their size.
                            Instances For
                              theorem Proofs.StableHLO.mnv4FwdGraphSync_full_shard (R : ) (hR : 0 < R) (N : ) (hN : 0 < N) (epsStr : String) {nCls : } (w : Mnv4BWeights nCls) (e : Fin RSHlo (N * (3 * 224 * 224))) (X : Vec (R * N * (3 * 224 * 224))) (he : ∀ (r : Fin R), den (e r) = batchShard R N (3 * 224 * 224) X r) (r : Fin R) :
                              den (mnv4FwdGraphSync_full R hR N epsStr w e r) = batchShard R N nCls (mobilenetv4ForwardB_full (R * N) w X) r

                              ⭐⭐ T2 at synchronised BatchNorm: replica r's forward IS shard r of the global-batch forward. Given that the replicas' inputs are the shards of one batch X of R·N images, the sync-BN graph on replica r denotes batchShard r of mobilenetv4ForwardB_full (R * N) w X — the committed batch-BN forward, at the global batch. Eight stage lemmas — the stem, the fused stage, the five resolution groups, the head — the shard hypothesis threaded from each into the next, over the forward's own prefixes.