Documentation

LeanPool.Superdiffusion.Algsuperdiff.Section4.Provider.ExcessDecay.SlotTransportChildCube

SlotTransportChildCube #

Ported from scottnarmstrong/Superdiffusion at 7f20476385d4af418f110303085ad0740c9eba46. Module imports, support namespace and local option directives adapted for Lean Pool.

Transporting the good-event caps from the parent cube to sub-cubes #

The printed consumers read them at sub-cubes of the parent and at the larger indices s/6 and s/4:

This module performs that transport for triadic sub-cubes of the parent, at the field and comparator of the parent (which is exactly how the manuscript writes it: 𝓔_{t,∞,q}(y+□_{n+1}; ã_{L,n+2}, σ_{n+2}), the parent's flux-corrected field on the smaller cube).

What is transported, and what is NOT #

Transported (proved below, unconditionally):

  1. the index change s/8 → u for every u ≥ s/8, at no cost — 𝓔 is antitone in its index (StabilityIndexCube.lean);
  2. the scale-exponent change q = 2 → q = 1, at no cost, via the manuscript's own e.compareEqs (StabilityExponentComparison.lean): it converts 𝓔_{s/4,∞,1} into 𝓔_{s/8,∞,2}, i.e. straight onto the annular anchor's own index;
  3. the cube change parent → triadic descendant at depth h, at cost 3^{(s/8)·h} (≤ 3^{1/8} < 1.15 for a one-scale descent and s ≤ 1).

In CoarseGraining's carrier the shells of an off-grid cube are maxima over the translated grid, which is disjoint from the parent's grid, so no inclusion or monotonicity argument reaches them; the printed route is l.lambdas.stability, whose proof is a greedy Whitney-type decomposition of the off-grid cube by parent-grid subcubes at all deeper scales, plus subadditivity of σ_*^{-1} and a packing count.

Consequently the geometry lemma proved here — the child inclusion that the manuscript itself silently uses — is recorded as a verified input to that missing lemma, not as a substitute for it.

Main definitions #

Main results #

Deviations from print, recorded #

  1. Grid, not continuum. All three cap statements quantify over descendantsAtScale (originCube d (n+2)) k, never over translates. Nothing below is presented as e.mathcalE.stability.applied or as l.lambdas.stability.
  2. The printed intermediate rung is skipped. The printed chain goes 𝓔_{s/4,∞,1} ≤ C 𝓔_{s/6,∞,2} ≤ 𝓔_{s/8,∞,2} ≤ C. The route here is 𝓔_{s/4,∞,1} ≤ 𝓔_{s/8,∞,2}(same cube) ≤ 3^{(s/8)h} 𝓔_{s/8,∞,2}(parent) ≤ C/2: the same endpoint, one rung fewer, and with explicit constants. The printed first inequality itself (at the index s/6) is not proved; see StabilityExponentComparison.lean.

References #

1. The geometry the manuscript uses without comment #

2. The parent's functionals read at a sub-cube #

𝓔_{s,∞,2}(Q; a_L − (κ_L−κ_m)_{□_m}, σ_m): the parent's flux-corrected field and comparator, evaluated on an arbitrary triadic cube Q.

This is the manuscript's own shorthand — the display carries 𝓔_{s/6,∞,2}(y+□_{n+1}; ã_{L,n+2}, σ_{n+2}), i.e. the field and comparator of the parent cube z+□_{n+2} on the smaller cube. Translated centres are realized, as everywhere in Section 4, by translating the sample (resolution A4).

Equations
  • One or more equations did not get rendered due to their size.
Instances For

    max{σ_m⁻¹Λ_{s,2}(Q), σ_mλ_{s,2}⁻¹(Q)} at the parent's field and comparator.

    Equations
    • One or more equations did not get rendered due to their size.
    Instances For

      At the cube that carries the flux correction, the sub-cube functional is the proved literal error of ErrorAtoms.

      3. The q = 2 cap at every triadic sub-cube #

      theorem Algsuperdiff.Section4.Provider.ExcessDecay.ae_errorOn_descendant_le_harmonicSlot (d : ℕ) [NeZero d] :
      ∃ (C : ℝ), 0 < C ∧ ∀ (M : Section3.ABKModel d), ∀ s ∈ Set.Icc (64 * M.gamma) 1, M.gamma ≤ C⁻¹ * Section3.Disorder.cstar M ^ 10 → M.gamma * |Real.log M.gamma| ^ 2 ≤ (s / 8).rpow (3 / 2) * Section3.Disorder.cstar M ^ 2 * (1 / 2) → ∀ (hs : 0 < s) (n : ℤ) (z : HCPolySupport.Vec d), ∀ᵐ (omega : Section3.Cutoff.CutoffSample d) ∂↑(Section3.Cutoff.cutoffSampleLaw M), omega ∈ Frozen.Section4.goodEventAt M (Support.cgEllipLowerConstant d) (n + 2) z ⟨s / 8, ⋯⟩ (1 / 2) → ∀ (L : ℤ), n + 2 ≤ L → ∀ (k : ℤ), ∀ Q ∈ HCPolySupport.descendantsAtScale (HCPolySupport.originCube d (n + 2)) k, ∀ (u : ℝ), s / 8 ≤ u → fluxCorrectedErrorOn M L (n + 2) Q u (Section3.Cutoff.translateCutoffSample z omega) ≤ Real.rpow 3 (s / 8 * ↑(n + 2 - k).toNat) * (C * (1 / 2))

      The caps step transported to triadic sub-cubes and to every larger index.

      On the harmonic statement's good event 𝒢(n+2, z; s/8, 1/2), for every L ≥ n+2, every triadic descendant Q of □_{n+2} at scale k, and every index u ≥ s/8,

      𝓔_{u,∞,2}(Q; ã_{L,n+2}, σ_{n+2})  ≤  3^{(s/8)·(n+2−k)} · C/2 .
      

      The index change is free and the cube change costs the explicit factor; the right-hand side is a constant, which is what the downstream Caccioppoli and coarse-graining steps consume. At k = n+1 and u = s/6 this is the middle inequality of e.good.set.giveth.v2 in its grid rendering (deviation 1).

      4. The q = 1 cap: the first inequality of e.good.set.giveth.v2 #

      5. e.bound.Lambdas.by.Es.v2 at every triadic sub-cube #

      theorem Algsuperdiff.Section4.Provider.ExcessDecay.ae_boundLambdasByEs_descendant_harmonicSlot (d : ℕ) [NeZero d] :
      ∃ (C : ℝ), 0 < C ∧ ∀ (M : Section3.ABKModel d), ∀ s ∈ Set.Icc (64 * M.gamma) 1, M.gamma ≤ C⁻¹ * Section3.Disorder.cstar M ^ 10 → M.gamma * |Real.log M.gamma| ^ 2 ≤ (s / 8).rpow (3 / 2) * Section3.Disorder.cstar M ^ 2 * (1 / 2) → ∀ (hs : 0 < s) (n : ℤ) (z : HCPolySupport.Vec d), ∀ᵐ (omega : Section3.Cutoff.CutoffSample d) ∂↑(Section3.Cutoff.cutoffSampleLaw M), omega ∈ Frozen.Section4.goodEventAt M (Support.cgEllipLowerConstant d) (n + 2) z ⟨s / 8, ⋯⟩ (1 / 2) → ∀ (L : ℤ), n + 2 ≤ L → ∀ (k : ℤ), ∀ Q ∈ HCPolySupport.descendantsAtScale (HCPolySupport.originCube d (n + 2)) k, ∀ (u : ℝ), s / 8 ≤ u → fluxCorrectedEllipticityRatioMaxOn M L (n + 2) Q u (Section3.Cutoff.translateCutoffSample z omega) ≤ 2 * ↑d * ((Real.rpow 3 (s / 8 * ↑(n + 2 - k).toNat) * (C * (1 / 2))) ^ 2 + 1)

      e.bound.Lambdas.by.Es.v2 transported to triadic sub-cubes.

      On the harmonic statement's good event, for every L ≥ n+2, every triadic descendant Q of □_{n+2} at scale k and every index u ≥ s/8,

      max{ σ_{n+2}⁻¹Λ_{u,2}(Q; ã_{L,n+2}) , σ_{n+2}λ_{u,2}⁻¹(Q; ã_{L,n+2}) }
            ≤  2d ( (3^{(s/8)(n+2−k)} · C/2)² + 1 ) .
      

      This is the input the coarse-grained Caccioppoli step e.energy.bound.interior consumes, at the outer cube of its Caccioppoli pair — provided that outer cube is a triadic descendant of the parent.

      theorem Algsuperdiff.Section4.Provider.ExcessDecay.ae_boundLambdasByEs_parent_index_le_harmonicSlot (d : ℕ) [NeZero d] :
      ∃ (C : ℝ), 0 < C ∧ ∀ (M : Section3.ABKModel d), ∀ s ∈ Set.Icc (64 * M.gamma) 1, M.gamma ≤ C⁻¹ * Section3.Disorder.cstar M ^ 10 → M.gamma * |Real.log M.gamma| ^ 2 ≤ (s / 8).rpow (3 / 2) * Section3.Disorder.cstar M ^ 2 * (1 / 2) → ∀ (hs : 0 < s) (n : ℤ) (z : HCPolySupport.Vec d), ∀ᵐ (omega : Section3.Cutoff.CutoffSample d) ∂↑(Section3.Cutoff.cutoffSampleLaw M), omega ∈ Frozen.Section4.goodEventAt M (Support.cgEllipLowerConstant d) (n + 2) z ⟨s / 8, ⋯⟩ (1 / 2) → ∀ (L : ℤ), n + 2 ≤ L → ∀ (u : ℝ), s / 8 ≤ u → fluxCorrectedEllipticityRatioMax M L (n + 2) u (Section3.Cutoff.translateCutoffSample z omega) ≤ 2 * ↑d * ((C * (1 / 2)) ^ 2 + 1)

      e.bound.Lambdas.by.Es.v2 at the parent cube, for every index u ≥ s/8.

      max{ σ_{n+2}⁻¹Λ_{u,2}(z+□_{n+2}; ã) , σ_{n+2}λ_{u,2}⁻¹(z+□_{n+2}; ã) } · 1_𝒢
            ≤  2d((C/2)² + 1) .