lean/OAI/Geometry/CubicTorus/Variation/ComponentDivergence.lean

import Mathlib
import OAI.Geometry.CubicTorus.Estimates.CorrectedChain

namespace OAI

section
section
noncomputable section
open MeasureTheory Set Filter
open scoped ENNReal NNReal Topology RealInnerProductSpace
namespace CubicTorus
variable {X : Type*} [NormedAddCommGroup X] [NormedSpace ℝ X]
namespace Periodic

lemma simultaneousCofactor_second_deriv (l : List Variation) (x n : Cover) :
    deriv (deriv (fun t ↦ chainCofactor (simultaneousChain l t) x n)) 0=(normalJet l x n).2.2 := by
  induction l using List.reverseRecOn with
  | nil => simp [simultaneousChain,chainCofactor,normalJet]
  | append_singleton l a ih =>
    have hm : ContDiff ℝ (⊤ : ℕ∞) (fun t : ℝ ↦ chainMove (simultaneousChain l t) x) :=
      (simultaneousMove_smooth l).comp (contDiff_id.prodMk contDiff_const)
    have hc : ContDiff ℝ (⊤ : ℕ∞) (fun t : ℝ ↦ chainCofactor (simultaneousChain l t) x n) :=
      (simultaneousCofactor_smooth l).comp (contDiff_id.prodMk (contDiff_const : ContDiff ℝ (⊤ : ℕ∞) (fun _ : ℝ ↦ (x,n))))
    have hf : ContDiff ℝ (⊤ : ℕ∞) (fun t : ℝ ↦ coordinateNormalVelocity a.coordinate a.function
      (chainMove (simultaneousChain l t) x) (chainCofactor (simultaneousChain l t) x n)) :=
      (wallVelocity_contDiff a).comp (hm.prodMk hc)
    have he : (fun t ↦ chainCofactor (simultaneousChain (l++[a]) t) x n)=
        (fun t ↦ chainCofactor (simultaneousChain l t) x n+
          t • coordinateNormalVelocity a.coordinate a.function (chainMove (simultaneousChain l t) x)
            (chainCofactor (simultaneousChain l t) x n)) := by
      funext t
      simp [simultaneousChain,List.map_append,chainCofactor_append,chainCofactor,coordinateCofactor_eq]
    rw [he,second_deriv_add_time_smul hc hf,ih,normalJet_append]
    dsimp only
    congr 2
    have hdf : HasFDerivAt (fun p : Cover×Cover ↦ coordinateNormalVelocity a.coordinate a.function p.1 p.2)
        (fderiv ℝ (fun p : Cover×Cover ↦ coordinateNormalVelocity a.coordinate a.function p.1 p.2) (x,n))
        (chainMove (simultaneousChain l 0) x,chainCofactor (simultaneousChain l 0) x n) := by
      simpa only [simultaneousMove_zero,simultaneousCofactor_zero] using
        ((wallVelocity_contDiff a).differentiable (by simp) (x,n)).hasFDerivAt
    have hd := hdf.comp_hasDerivAt 0
      ((hm.differentiable (by simp) 0).hasDerivAt.prodMk (hc.differentiable (by simp) 0).hasDerivAt)
    simpa only [Function.comp_def,simultaneousMove_deriv,simultaneousCofactor_deriv,
      (normalJet_first l x n).1,(normalJet_first l x n).2] using hd.deriv

theorem simultaneousArea_second_deriv (l : List Variation) (μ : FiniteMeasure NormalBundle) :
    deriv (deriv (fun t ↦ ∫ z,‖chainCofactor (simultaneousChain l t) z.1 z.2‖
      ∂(μ : Measure NormalBundle))) 0 =
      ∫ z,‖chainNormalVelocity l z.1 z.2‖^2-⟪(z.2 : Cover),chainNormalVelocity l z.1 z.2⟫^2+
        ⟪(z.2 : Cover),(normalJet l z.1 z.2).2.2⟫ ∂(μ : Measure NormalBundle) := by
  have h := normalArea_second_derivative (simultaneousCofactor_smooth l)
    (by intro p _; exact simultaneousCofactor_zero l p.1 p.2) μ
  simpa only [normalEmbedding,simultaneousCofactor_deriv,simultaneousCofactor_second_deriv] using h

end Periodic
end CubicTorus

end
end

section

noncomputable section
open MeasureTheory Set Filter
open scoped ENNReal NNReal Topology RealInnerProductSpace
namespace CubicTorus
namespace Periodic

def componentDivergence (a : Variation) (x : Cover) : ℝ :=
  fderiv ℝ a.function x (EuclideanSpace.single a.coordinate 1)

lemma componentDivergence_smooth (a : Variation) : ContDiff ℝ (⊤ : ℕ∞) (componentDivergence a) :=
  (a.smooth.fderiv_right (by simp)).clm_apply contDiff_const

def massJet (l : List Variation) (x : Cover) : Cover×ℝ×ℝ :=
  l.foldl (fun j a ↦ (j.1+a.function x • EuclideanSpace.single a.coordinate 1,
    j.2.1+componentDivergence a x,
    j.2.2+2*(fderiv ℝ (componentDivergence a) x j.1+j.2.1*componentDivergence a x))) (0,0,0)

lemma massJet_append (l : List Variation) (a : Variation) (x : Cover) :
    massJet (l++[a]) x = ((massJet l x).1+a.function x • EuclideanSpace.single a.coordinate 1,
      (massJet l x).2.1+componentDivergence a x,
      (massJet l x).2.2+2*(fderiv ℝ (componentDivergence a) x (massJet l x).1+
        (massJet l x).2.1*componentDivergence a x)) := by
  simp only [massJet,List.foldl_append,List.foldl_cons,List.foldl_nil]

lemma massJet_first (l : List Variation) (x : Cover) :
    (massJet l x).1=chainVelocity l x := by
  induction l using List.reverseRecOn with
  | nil => simp [massJet,chainVelocity]
  | append_singleton l a ih =>
    simpa [massJet_append,chainVelocity,List.map_append] using
      congrArg (fun u ↦ u+a.function x • EuclideanSpace.single a.coordinate (1 : ℝ)) ih

lemma simultaneousJacobian_append (l : List Variation) (a : Variation) (x : Cover) (t : ℝ) :
    chainJacobian (simultaneousChain (l++[a]) t) x=chainJacobian (simultaneousChain l t) x+
      t*(chainJacobian (simultaneousChain l t) x*componentDivergence a (chainMove (simultaneousChain l t) x)) := by
  simp only [simultaneousChain,List.map_append,chainJacobian_append,List.map_cons,List.map_nil,
    chainJacobian,coordinateJacobian,mul_one,componentDivergence]
  ring

lemma simultaneousJacobian_deriv (l : List Variation) (x : Cover) :
    deriv (fun t ↦ chainJacobian (simultaneousChain l t) x) 0=(massJet l x).2.1 := by
  induction l using List.reverseRecOn with
  | nil => simp [simultaneousChain,chainJacobian,massJet]
  | append_singleton l a ih =>
    have hm : ContDiff ℝ (⊤ : ℕ∞) (fun t : ℝ ↦ chainMove (simultaneousChain l t) x) :=
      (simultaneousMove_smooth l).comp (contDiff_id.prodMk contDiff_const)
    have hj : ContDiff ℝ (⊤ : ℕ∞) (fun t : ℝ ↦ chainJacobian (simultaneousChain l t) x) :=
      (simultaneousJacobian_smooth l).comp (contDiff_id.prodMk contDiff_const)
    simp_rw [simultaneousJacobian_append l a x]
    simpa [massJet_append,ih] using deriv_add_time_smul hj (hj.mul ((componentDivergence_smooth a).comp hm))

lemma simultaneousJacobian_second_deriv (l : List Variation) (x : Cover) :
    deriv (deriv (fun t ↦ chainJacobian (simultaneousChain l t) x)) 0=(massJet l x).2.2 := by
  induction l using List.reverseRecOn with
  | nil => simp [simultaneousChain,chainJacobian,massJet]
  | append_singleton l a ih =>
    have hm : ContDiff ℝ (⊤ : ℕ∞) (fun t : ℝ ↦ chainMove (simultaneousChain l t) x) :=
      (simultaneousMove_smooth l).comp (contDiff_id.prodMk contDiff_const)
    have hj : ContDiff ℝ (⊤ : ℕ∞) (fun t : ℝ ↦ chainJacobian (simultaneousChain l t) x) :=
      (simultaneousJacobian_smooth l).comp (contDiff_id.prodMk contDiff_const)
    have hd : HasFDerivAt (componentDivergence a) (fderiv ℝ (componentDivergence a) x)
        (chainMove (simultaneousChain l 0) x) := by
      simpa only [simultaneousMove_zero] using
        ((componentDivergence_smooth a).differentiable (by simp) x).hasFDerivAt
    have hf := hd.comp_hasDerivAt 0 ((hm.differentiable (by simp) 0).hasDerivAt)
    have he := ((hj.differentiable (by simp) 0).hasDerivAt.mul hf).deriv
    simp only [Function.comp_def,simultaneousJacobian_zero,simultaneousMove_zero,
      simultaneousMove_deriv,simultaneousJacobian_deriv,one_mul] at he
    change deriv (fun t ↦ chainJacobian (simultaneousChain l t) x *
      componentDivergence a (chainMove (simultaneousChain l t) x)) 0 =
      (massJet l x).2.1*componentDivergence a x+fderiv ℝ (componentDivergence a) x (chainVelocity l x) at he
    simp_rw [simultaneousJacobian_append l a x]
    have hh := second_deriv_add_time_smul hj (hj.mul ((componentDivergence_smooth a).comp hm))
    simp only [smul_eq_mul,Function.comp_def] at hh
    rw [hh,ih,he,massJet_append]
    simp only [massJet_first]
    ring

lemma simultaneousMass_second_deriv (l : List Variation) (E : Set Torus) :
    deriv (deriv (fun t ↦ chainMass (simultaneousChain l t) E)) 0=
      ∫ x in fundamentalCube∩quotientMap ⁻¹' E,(massJet l x).2.2 := by
  simpa only [chainMass,simultaneousJacobian_second_deriv] using
    second_deriv_compact_parameter_integral isCompact_closedFundamentalCube
      (cubeIntersection_compact_carrier E) (simultaneousJacobian_smooth l) 0

end Periodic
end CubicTorus

end
end

section

noncomputable section
open MeasureTheory Set Filter
open scoped ENNReal NNReal Topology RealInnerProductSpace
namespace CubicTorus
namespace Periodic

theorem exists_chain_of_field {F : Cover → Cover} (hF : ContDiff ℝ (⊤ : ℕ∞) F)
    (hp : ∀ m x,F (x+latticeVector m)=F x) :
    ∃ l : List Variation,(∀ x,chainVelocity l x=F x) ∧
      (∀ E,chainFlux l E=∫ x in fundamentalCube∩quotientMap ⁻¹' E,divergence F x) ∧
      ∀ x n,⟪n,chainNormalVelocity l x n⟫=‖n‖^2*divergence F x-⟪n,fderiv ℝ F x n⟫ := by
  have hx (i : Fin 3) : ∃ a : Variation,a.coordinate=i ∧ a.function=(fun x ↦ F x i) :=
    exists_variation_of_function i ((EuclideanSpace.proj i : Cover →L[ℝ] ℝ).contDiff.comp hF)
      (fun m x ↦ by change F (x+latticeVector m) i=F x i; rw [hp])
  choose a ha hb using hx
  refine ⟨List.ofFn a,?_,?_,?_⟩
  · intro x
    simp only [chainVelocity,List.map_ofFn,List.sum_ofFn,Function.comp_apply,ha,hb]
    ext j
    simp [Finset.sum_apply,Pi.single_apply,smul_eq_mul]
  · intro E
    simp only [chainFlux,List.map_ofFn,List.sum_ofFn,Function.comp_apply,ha,hb]
    exact (flux_sum_components E hF).symm
  · intro x n
    simp only [chainNormalVelocity,List.map_ofFn,List.sum_ofFn,Function.comp_apply,ha,hb,
      inner_sum,coordinateNormalVelocity,inner_sub_right,real_inner_smul_right,
      real_inner_self_eq_norm_sq,inner_gradient_right,conj_trivial,
      Finset.sum_sub_distrib,← Finset.sum_mul]
    simp_rw [fderiv_component (hF.differentiable (by simp) x)]
    dsimp [divergence]
    congr 1
    · ring
    · simp [PiLp.inner_apply,EuclideanSpace.single,mul_comm]

theorem isMinimizerAt_stable_fields {V : ℝ} (hV : V∈Ioo 0 1)
    {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E) :
    ∃ (μ : FiniteMeasure NormalBundle) (H : ℝ),IsNormalMeasure E μ ∧
      (∀ F : Cover → Cover,ContDiff ℝ (⊤ : ℕ∞) F →
        (∀ n x,F (x+latticeVector n)=F x) →
        (∫ z,tangentialDivergence F z.1 z.2 ∂(μ : Measure NormalBundle))=
          H*(∫ z,⟪(z.2 : Cover),F z.1⟫ ∂(μ : Measure NormalBundle))) ∧
      ∀ F : Cover → Cover,ContDiff ℝ (⊤ : ℕ∞) F →
        (∀ n x,F (x+latticeVector n)=F x) →
        (∫ z,⟪(z.2 : Cover),F z.1⟫ ∂(μ : Measure NormalBundle))=0 →
        ∃ l : List Variation,(∀ x,deriv (fun t ↦ chainMove (simultaneousChain l t) x) 0=F x) ∧
          0≤deriv (deriv (fun t ↦ ∫ z,‖chainCofactor (simultaneousChain l t) z.1 z.2‖
            ∂(μ : Measure NormalBundle))) 0-
            H*deriv (deriv (fun t ↦ chainMass (simultaneousChain l t) E)) 0 := by
  obtain ⟨μ,H,hμ,hH,hs⟩ := isMinimizerAt_stable_periodic hV hE hmin
  refine ⟨μ,H,hμ,fun F hf hp ↦ weakCMC_identity hμ hH hf hp,?_⟩
  intro F hf hp hz
  obtain ⟨l,hl,hflux,_⟩ := exists_chain_of_field hf hp
  refine ⟨l,fun x ↦ (simultaneousMove_deriv l x).trans (hl x),hs l ?_⟩
  rw [simultaneousMass_deriv,hflux]
  obtain ⟨C,hC,hbound⟩ := periodic_bounded hf.continuous hp
  rw [← normalMeasure_flux hμ hf hp (by linarith : 0<C+1)
    (fun x ↦ (hbound x).trans (by linarith : C≤C+1))]
  exact hz

end Periodic
end CubicTorus

end
end

section

noncomputable section
open MeasureTheory Set Filter
open scoped ENNReal NNReal Topology RealInnerProductSpace
namespace CubicTorus
namespace Periodic

def chainQuadratic (E : Set Torus) (μ : FiniteMeasure NormalBundle) (H : ℝ)
    (l : List Variation) : ℝ :=
  (∫ z,‖chainNormalVelocity l z.1 z.2‖^2-⟪(z.2 : Cover),chainNormalVelocity l z.1 z.2⟫^2+
    ⟪(z.2 : Cover),(normalJet l z.1 z.2).2.2⟫ ∂(μ : Measure NormalBundle))-
    H*(∫ x in fundamentalCube∩quotientMap ⁻¹' E,(massJet l x).2.2)

theorem isMinimizerAt_expanded_stability {V : ℝ} (hV : V∈Ioo 0 1)
    {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E) :
    ∃ (μ : FiniteMeasure NormalBundle) (H : ℝ),IsNormalMeasure E μ ∧
      (∀ F : Cover → Cover,ContDiff ℝ (⊤ : ℕ∞) F →
        (∀ n x,F (x+latticeVector n)=F x) →
        (∫ z,tangentialDivergence F z.1 z.2 ∂(μ : Measure NormalBundle))=
          H*(∫ z,⟪(z.2 : Cover),F z.1⟫ ∂(μ : Measure NormalBundle))) ∧
      (∀ l : List Variation,chainFlux l E=0 → 0≤chainQuadratic E μ H l) ∧
      ∀ F : Cover → Cover,ContDiff ℝ (⊤ : ℕ∞) F →
        (∀ n x,F (x+latticeVector n)=F x) →
        (∫ z,⟪(z.2 : Cover),F z.1⟫ ∂(μ : Measure NormalBundle))=0 →
        ∃ l : List Variation,(∀ x,chainVelocity l x=F x) ∧
          chainFlux l E=0 ∧ 0≤chainQuadratic E μ H l := by
  obtain ⟨μ,H,hμ,hH,hs⟩ := isMinimizerAt_stable_periodic hV hE hmin
  have hq (l : List Variation) (hl : chainFlux l E=0) : 0≤chainQuadratic E μ H l := by
    have hh := hs l (by rw [simultaneousMass_deriv,hl])
    simpa only [chainQuadratic,simultaneousArea_second_deriv,simultaneousMass_second_deriv] using hh
  refine ⟨μ,H,hμ,fun F hf hp ↦ weakCMC_identity hμ hH hf hp,hq,?_⟩
  intro F hf hp hz
  obtain ⟨l,hl,hflux,_⟩ := exists_chain_of_field hf hp
  have hh : chainFlux l E=0 := by
    rw [hflux]
    obtain ⟨C,_,hbound⟩ := periodic_bounded hf.continuous hp
    have hC : 0<C+‖F 0‖+1 := by linarith [hbound 0,norm_nonneg (F 0)]
    rw [← normalMeasure_flux hμ hf hp hC (fun x ↦ (hbound x).trans (by linarith [norm_nonneg (F 0)] : C≤C+‖F 0‖+1))]
    exact hz
  exact ⟨l,hl,hh,hq l hh⟩

end Periodic
end CubicTorus

end
end

section

noncomputable section
open MeasureTheory Set Filter
open scoped ENNReal NNReal Topology RealInnerProductSpace
namespace CubicTorus

def coverTrace (L : Cover →L[ℝ] Cover) : ℝ :=
  ∑ i : Fin 3, L (EuclideanSpace.single i 1) i

lemma cover_decompose (v : Cover) : v=∑ i : Fin 3,v i • EuclideanSpace.single i 1 := by
  ext j
  simp [Pi.single_apply]

lemma cover_clm_component (L : Cover →L[ℝ] Cover) (v : Cover) (i : Fin 3) :
    L v i=∑ j : Fin 3,v j*L (EuclideanSpace.single j 1) i := by
  change (EuclideanSpace.proj i : Cover →L[ℝ] ℝ) (L v)=_
  conv_lhs => rw [cover_decompose v,map_sum,map_sum]
  simp only [map_smul,smul_eq_mul]
  rfl

@[simp] lemma coverTrace_zero : coverTrace 0=0 := by simp [coverTrace]
@[simp] lemma coverTrace_add (L M : Cover →L[ℝ] Cover) :
    coverTrace (L+M)=coverTrace L+coverTrace M := by simp [coverTrace,Finset.sum_add_distrib]
@[simp] lemma coverTrace_smul (a : ℝ) (L : Cover →L[ℝ] Cover) :
    coverTrace (a • L)=a*coverTrace L := by simp [coverTrace,Finset.mul_sum]

def coverTraceCLM : (Cover →L[ℝ] Cover) →L[ℝ] ℝ :=
  ({toFun := coverTrace, map_add' := coverTrace_add,
    map_smul' := by intro a L; exact coverTrace_smul a L} :
      (Cover →L[ℝ] Cover) →ₗ[ℝ] ℝ).toContinuousLinearMap

@[simp] lemma coverTraceCLM_apply (L : Cover →L[ℝ] Cover) : coverTraceCLM L=coverTrace L := rfl

lemma coverTrace_comp_comm (L M : Cover →L[ℝ] Cover) :
    coverTrace (L.comp M)=coverTrace (M.comp L) := by
  simp only [coverTrace,ContinuousLinearMap.comp_apply]
  conv_lhs => enter [2,i]; rw [cover_clm_component]
  conv_rhs => enter [2,i]; rw [cover_clm_component]
  rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro i _
  apply Finset.sum_congr rfl
  intro j _
  ring

lemma coverTrace_smulRight (l : Cover →L[ℝ] ℝ) (v : Cover) :
    coverTrace (l.smulRight v)=l v := by
  conv_rhs => rw [cover_decompose v]
  simp only [coverTrace,ContinuousLinearMap.smulRight_apply,PiLp.smul_apply,
    smul_eq_mul,map_sum,map_smul]
  apply Finset.sum_congr rfl
  intro i _
  ring

lemma divergence_eq_coverTrace (F : Cover → Cover) (x : Cover) :
    divergence F x=coverTrace (fderiv ℝ F x) := rfl

def cofactorLinear (L : Cover →L[ℝ] Cover) (n : Cover) : Cover :=
  coverTrace L • n-L.adjoint n

def cofactorQuadratic (L : Cover →L[ℝ] Cover) (n : Cover) : Cover :=
  ((coverTrace L)^2-coverTrace (L.comp L)) • n-
    (2*coverTrace L) • L.adjoint n+2 • L.adjoint (L.adjoint n)

lemma cofactorLinear_add (L M : Cover →L[ℝ] Cover) (n : Cover) :
    cofactorLinear (L+M) n=cofactorLinear L n+cofactorLinear M n := by
  simp only [cofactorLinear,coverTrace_add,map_add,add_apply]
  module

lemma cofactorQuadratic_add (L M : Cover →L[ℝ] Cover) (n : Cover) :
    cofactorQuadratic (L+M) n=cofactorQuadratic L n+cofactorQuadratic M n+
      2 • (cofactorLinear M (cofactorLinear L n)-cofactorLinear (M.comp L) n) := by
  simp only [cofactorQuadratic,cofactorLinear,coverTrace_add,ContinuousLinearMap.add_comp,
    ContinuousLinearMap.comp_add,coverTrace_comp_comm L M,map_add,add_apply,
    ContinuousLinearMap.adjoint_comp,ContinuousLinearMap.comp_apply,map_sub,map_smul]
  module

end CubicTorus

end
end

section

noncomputable section
open MeasureTheory Set Filter
open scoped ENNReal NNReal Topology RealInnerProductSpace
namespace CubicTorus

theorem isMinimizerAt_halfspace_L1_tilt_small {V : ℝ} (hV : V ∈ Ioo 0 1)
    {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E)
    {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) {H : ℝ}
    (hH : ∀ D : WallVariation, normalFirstVariation μ D =
      H*directionalFlux E D.coordinate D.function)
    {n : Cover} (hn : ‖n‖ = 1) {ε : ℝ} (hε : 0 < ε) :
    ∃ η : ℝ, 0 < η ∧ ∀ (c : MovingCenter.InteriorCenter) (r : ℝ),
      0 < r → r < η →
      (∫ x in Metric.closedBall (0 : Cover) 1,
        |blowupCharacteristic E c r x-(coverHalfspace n).indicator (fun _ ↦ (1 : ℝ)) x|) < η →
      (∫ z, blowupTilt n z ∂(blowupNormalMeasure μ c r 2 : Measure BlowupNormalBundle)) < ε := by
  by_contra h
  push Not at h
  let d : ℕ → ℝ := fun i ↦ 1/((i : ℝ)+1)
  have hd (i : ℕ) : 0 < d i := by dsimp [d]; positivity
  have hb (i : ℕ) := h (d i) (hd i)
  choose c r hr hrd he ht using hb
  have hdlim : Tendsto d atTop (𝓝 0) := tendsto_one_div_add_atTop_nhds_zero_nat
  have hrlim : Tendsto r atTop (𝓝 0) :=
    squeeze_zero (fun i ↦ (hr i).le) (fun i ↦ (hrd i).le) hdlim
  have hconv : Tendsto (fun i ↦ ∫ x in Metric.closedBall (0 : Cover) 1,
      |blowupCharacteristic E (c i) (r i) x-
        (coverHalfspace n).indicator (fun _ ↦ (1 : ℝ)) x|) atTop (𝓝 0) :=
    squeeze_zero (fun i ↦ integral_nonneg (fun _ ↦ abs_nonneg _))
      (fun i ↦ (he i).le) hdlim
  obtain ⟨ν,k,U,hU,hν,_,hstat⟩ := isMinimizerAt_moving_paired_normal_limit
    hV hE hmin hμ hH c r hr hrlim (measurableSet_coverHalfspace n) hconv
  have hflux (F : Cover → Cover) (hF : ContDiff ℝ (⊤ : ℕ∞) F)
      (hs : tsupport F ⊆ Metric.closedBall (0 : Cover) 1) := (hstat F hF hs).2
  have heq := moving_blowup_perimeter_eq_normal_ball hV hE hmin hμ
    (fun i ↦ c (i+k)) (fun i ↦ r (i+k)) (fun i ↦ hr _)
    ((hrlim.comp (tendsto_add_atTop_nat k)).mono_left hU)
    (measurableSet_coverHalfspace n)
    ((hconv.comp (tendsto_add_atTop_nat k)).mono_left hU) hν hflux
    (by norm_num : (0 : ℝ) < 1/2) (by norm_num : (1/2 : ℝ) ≤ 1)
  have hmodel : ∀ᵐ x : Cover ∂volume, x ∈ Metric.ball (0 : Cover) 1 →
      (x ∈ coverHalfspace n ↔ x ∈ coverHalfspace n) := ae_of_all _ (by simp)
  have hmass : (ν : Measure BlowupNormalBundle).real
      {z | z.1 ∈ Metric.ball (0 : Cover) (1/2)} = Real.pi*(1/2)^2 := by
    rw [Measure.real_def,← heq,
      halfspace_model_perimeter_ball (measurableSet_coverHalfspace n) hn hmodel
        (by norm_num) (by norm_num), ENNReal.toReal_ofReal (by positivity)]
  have hflat := flat_set_limit_normal (measurableSet_coverHalfspace n) hn hmodel hmass hflux
  have htilt := flat_moving_normal_tilt_limit
    (fun i ↦ (c (i+k) : Cover)) (fun i ↦ r (i+k)) hν hflat
  obtain ⟨i,hi⟩ := (htilt.eventually (Iio_mem_nhds hε)).exists
  exact (not_lt_of_ge (ht (i+k))) hi

theorem isMinimizerAt_halfspace_L1_normal_charts {V : ℝ} (hV : V ∈ Ioo 0 1)
    {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E)
    (hcenter : quotientMap cubeCenter ∈ frontier (openRepresentative E))
    {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) {H : ℝ}
    (hH : ∀ D : WallVariation, normalFirstVariation μ D =
      H*directionalFlux E D.coordinate D.function) :
    ∃ C K ρ δ : ℝ, 0 < C ∧ 0 < K ∧ 0 < ρ ∧ ρ ≤ 1/16 ∧ 0 < δ ∧
      ∀ n : Cover, ‖n‖ = 1 → ∀ e : ℝ, 0 < e → e ≤ δ →
      ∃ η : ℝ, 0 < η ∧ ∀ (c : Cover) (r : ℝ),
        ‖c-cubeCenter‖ ≤ 1/16 → 0 < r → r < η →
        (∫ x in Metric.closedBall (0 : Cover) 1,
          |blowupCharacteristic E c r x-(coverHalfspace n).indicator (fun _ ↦ (1 : ℝ)) x|) < η →
        BoundaryNormalChart E c n (r/272) e C K ρ := by
  obtain ⟨R,C,K,ρ,hR,hC,hK,hρ,hρs,hmod⟩ :=
    MovingCenter.isMinimizerAt_moving_normal_modulus hV hE hmin hcenter
  obtain ⟨N,hN,hp,hu⟩ := normalMeasure_polar_unit hμ
  obtain ⟨δ,hδ,hcharts⟩ := hmod μ hμ N hN hp hu
  refine ⟨C,K,ρ,δ,hC,hK,hρ,hρs,hδ,?_⟩
  intro n hn e he heδ
  obtain ⟨η,hη,hsmall⟩ := isMinimizerAt_halfspace_L1_tilt_small hV hE hmin hμ hH hn
    (show 0 < e^2/272^2 by positivity)
  refine ⟨min η (min (272*R) (min (272*δ*e^2) 1)),by positivity,?_⟩
  intro c r hc hr hrs hL1
  have hrη : r < η := hrs.trans_le (min_le_left _ _)
  have hrR : r/272 ≤ R := by
    have hh := hrs.trans_le ((min_le_right _ _).trans (min_le_left _ _))
    linarith
  have hratio : (r/272)/e^2 ≤ δ := by
    apply (div_le_iff₀ (sq_pos_of_pos he)).mpr
    have hh := hrs.trans_le ((min_le_right _ _).trans
      ((min_le_right _ _).trans (min_le_left _ _)))
    linarith
  have hr1 : r < 1 := hrs.trans_le ((min_le_right _ _).trans
    ((min_le_right _ _).trans (min_le_right _ _)))
  let d : MovingCenter.InteriorCenter := ⟨c,by linarith⟩
  have ht := hsmall d r hr hrη (hL1.trans_le (min_le_left _ _))
  have hchart : Metric.ball c (r/8) ⊆ {x | ∀ j, 0 < x j ∧ x j < 1} :=
    Metric.ball_subset_closedBall.trans (MovingCenter.closedBall_interior (c := d) (by linarith))
  have htilt := spatial_tilt_le_blowupTilt hN hp hu c n hr hchart
  have hbound : (∫ x in Metric.closedBall (quotientMap c) (17*(r/272)), ‖N x-n‖^2
      ∂(spatialNormalMeasure μ : Measure Torus)) ≤ (r/272)^2*e^2 := by
    rw [show 17*(r/272)=r/16 by ring]
    calc
      _ ≤ _ := htilt
      _ ≤ r^2*(e^2/272^2) := mul_le_mul_of_nonneg_left ht.le (sq_nonneg _)
      _ = _ := by ring
  exact hcharts c hc n (r/272) e hn (div_pos hr (by norm_num)) hrR he heδ hratio hbound

end CubicTorus

end
end

section

noncomputable section
open MeasureTheory Set Filter
open scoped ENNReal NNReal Topology RealInnerProductSpace
namespace CubicTorus

lemma localL1_eventually_lt_model {g : ℕ → Cover → ℝ}
    (hg : ∀ i, Measurable (g i)) (hgb : ∀ i x, |g i x| ≤ 1)
    {f F : Cover → ℝ} (hf : Measurable f) (hfb : ∀ x, |f x| ≤ 1)
    (hF : Measurable F) (hFb : ∀ x, |F x| ≤ 1) {R : ℝ} {l : Filter ℕ}
    (hconv : Tendsto (fun i ↦ ∫ x in Metric.closedBall (0 : Cover) R,
      |g i x-f x|) l (𝓝 0)) {η : ℝ}
    (hclose : (∫ x in Metric.closedBall (0 : Cover) R, |f x-F x|) < η) :
    ∀ᶠ i in l, (∫ x in Metric.closedBall (0 : Cover) R, |g i x-F x|) < η := by
  have he := hconv.eventually (Iio_mem_nhds (sub_pos.mpr hclose))
  filter_upwards [he] with i hi
  let m : Measure Cover := volume.restrict (Metric.closedBall (0 : Cover) R)
  have ht := dist_triangle (boundedFunctionL1 m (g i) (hg i) (hgb i))
    (boundedFunctionL1 m f hf hfb) (boundedFunctionL1 m F hF hFb)
  simp only [boundedFunctionL1_dist] at ht
  change (∫ x in Metric.closedBall (0 : Cover) R, |g i x-F x|) ≤
    (∫ x in Metric.closedBall (0 : Cover) R, |g i x-f x|) +
    (∫ x in Metric.closedBall (0 : Cover) R, |f x-F x|) at ht
  linarith

theorem isMinimizerAt_close_limit_fixed_scale_graphs {V : ℝ} (hV : V ∈ Ioo 0 1)
    {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E)
    (hcenter : quotientMap cubeCenter ∈ frontier (openRepresentative E))
    {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) {H : ℝ}
    (hH : ∀ D : WallVariation, normalFirstVariation μ D =
      H*directionalFlux E D.coordinate D.function)
    {n : Cover} (hn : ‖n‖ = 1) :
    ∃ η : ℝ, 0 < η ∧
      ∀ (c : ℕ → MovingCenter.InteriorCenter) (r : ℕ → ℝ),
        (∀ i, 0 < r i) → Tendsto r atTop (𝓝 0) →
        (∀ᶠ i in atTop, ‖(c i : Cover)-cubeCenter‖ ≤ 1/32) →
      ∀ A : Set Cover, MeasurableSet A →
        Tendsto (fun i ↦ ∫ x in Metric.closedBall (0 : Cover) 1,
          |blowupCharacteristic E (c i) (r i) x-A.indicator (fun _ ↦ (1 : ℝ)) x|)
          atTop (𝓝 0) →
        (∀ ρ : ℝ, 0 < ρ → ρ ≤ 1 →
          0 < volume.real (A ∩ Metric.ball (0 : Cover) ρ) ∧
          0 < volume.real (Aᶜ ∩ Metric.ball (0 : Cover) ρ)) →
        (∫ x in Metric.closedBall (0 : Cover) 1,
          |A.indicator (fun _ ↦ (1 : ℝ)) x-
            (coverHalfspace n).indicator (fun _ ↦ (1 : ℝ)) x|) < η →
        ∀ᶠ i in atTop, ∃ a : Cover, dist a (c i : Cover) < r i/(544*4096) ∧
          ∃ g : Plane → ℝ, LipschitzWith (1/4) g ∧
            ContDiffOn ℝ 1 g (Metric.ball 0 ((r i/544)/1024)) ∧
            (∀ y ∈ Metric.ball (0 : Plane) ((r i/544)/1024),
              quotientMap a+quotientMap (normalGraph n g y) ∈ frontier (openRepresentative E) ∧
              ‖normalGraph n g y‖ < (r i/544)/512) ∧
            (∀ x ∈ quotientMap ⁻¹' frontier (openRepresentative E) ∩ Metric.ball a ((r i/544)/128),
              normalGraph n g (normalPlaneCoordinates n (x-a)) = x-a) := by
  obtain ⟨R,hR,hgraphs⟩ := MovingCenter.isMinimizerAt_moving_C1_graph hV hE hmin hcenter
  obtain ⟨N,hN,hp,hu⟩ := normalMeasure_polar_unit hμ
  obtain ⟨δ,hδ,hgraph⟩ := hgraphs μ hμ N hN hp hu
  let e := δ/2
  have he : 0 < e := by dsimp [e]; positivity
  obtain ⟨η,hη,hsmall⟩ := isMinimizerAt_halfspace_L1_tilt_small hV hE hmin hμ hH hn
    (show 0 < e^2/544^2 by positivity)
  refine ⟨η,hη,?_⟩
  intro c r hr hrlim hc A hA hconv hphases hclose
  have hpositive : 0 < min η (min (544*R) (min (544*δ*e^2) (1/32))) := by positivity
  have hs := hrlim.eventually (Iio_mem_nhds hpositive)
  have hL1 := localL1_eventually_lt_model
    (fun i ↦ measurable_blowupCharacteristic hE (c i) (r i))
    (fun i ↦ blowupCharacteristic_bound E (c i) (r i))
    (measurable_const.indicator hA) (cover_indicator_bound A)
    (measurable_const.indicator (measurableSet_coverHalfspace n))
    (cover_indicator_bound (coverHalfspace n)) hconv hclose
  have hpoints := isMinimizerAt_moving_frontier_approximation hV hE hmin c r hr hrlim hA hconv
    (by norm_num : (0:ℝ) < 1/(544*4096)) (by norm_num : (1:ℝ)/(544*4096) ≤ 1)
    (hphases _ (by norm_num) (by norm_num))
  filter_upwards [hc,hs,hL1,hpoints] with i hci hri hL1i hpoint
  have hrη : r i < η := hri.trans_le (min_le_left _ _)
  have hri' := hri.trans_le (min_le_right _ _)
  have hti := hsmall (c i) (r i) (hr i) hrη hL1i
  obtain ⟨a,ha,hbase⟩ := hpoint
  have had : dist a (c i : Cover) < r i/(544*4096) := by
    simpa only [Metric.mem_ball,div_eq_mul_inv,one_mul] using ha
  have hrR : r i/544 ≤ R := by have hh := hri'.trans_le (min_le_left _ _); linarith
  have hrsmall : r i < 1/32 := hri'.trans_le ((min_le_right _ _).trans (min_le_right _ _))
  have hratio : (r i/544)/e^2 ≤ δ := by
    apply (div_le_iff₀ (sq_pos_of_pos he)).mpr
    have hh := hri'.trans_le ((min_le_right _ _).trans (min_le_left _ _))
    linarith
  have hnear : ‖a-cubeCenter‖ ≤ 1/16 := by
    have hh := dist_triangle a (c i : Cover) cubeCenter
    simp only [dist_eq_norm] at hh had
    linarith
  have hchart : Metric.ball (c i : Cover) (r i/8) ⊆ {x | ∀ j, 0 < x j ∧ x j < 1} :=
    Metric.ball_subset_closedBall.trans (MovingCenter.closedBall_interior (by linarith : r i/8 < 3/8))
  have htilt := spatial_tilt_le_blowupTilt hN hp hu (c i) n (hr i) hchart
  have hadq : dist (quotientMap a) (quotientMap (c i)) < r i/(544*4096) := by
    rw [dist_eq_norm,← quotientMap_sub]
    exact (norm_quotientMap_le _).trans_lt (by simpa only [dist_eq_norm] using had)
  have hsub : Metric.closedBall (quotientMap a) (17*(r i/544)) ⊆
      Metric.closedBall (quotientMap (c i)) (r i/16) := by
    intro x hx
    have hx' : dist x (quotientMap a) ≤ 17*(r i/544) := hx
    have hh := dist_triangle x (quotientMap a) (quotientMap (c i))
    change dist x (quotientMap (c i)) ≤ r i/16
    linarith [hr i]
  have hbound : (∫ x in Metric.closedBall (quotientMap a) (17*(r i/544)), ‖N x-n‖^2
      ∂(spatialNormalMeasure μ : Measure Torus)) ≤ (r i/544)^2*e^2 := by
    calc
      _ ≤ (∫ x in Metric.closedBall (quotientMap (c i)) (r i/16), ‖N x-n‖^2
        ∂(spatialNormalMeasure μ : Measure Torus)) := setIntegral_mono_set
          (polar_tilt_integrable hN hu n).integrableOn (Eventually.of_forall fun _ ↦ sq_nonneg _) hsub.eventuallyLE
      _ ≤ _ := htilt
      _ ≤ (r i)^2*(e^2/544^2) := mul_le_mul_of_nonneg_left hti.le (sq_nonneg _)
      _ = _ := by ring
  exact ⟨a,had,hgraph a hnear hbase n (r i/544) e hn (div_pos (hr i) (by norm_num))
    hrR he (by dsimp [e]; linarith) hratio hbound⟩

end CubicTorus

end
end

section

noncomputable section
open MeasureTheory Set Filter
open scoped ENNReal NNReal Topology RealInnerProductSpace
namespace CubicTorus

theorem isMinimizerAt_close_limit_fixed_scale_normals {V : ℝ} (hV : V ∈ Ioo 0 1)
    {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E)
    (hcenter : quotientMap cubeCenter ∈ frontier (openRepresentative E))
    {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) {H : ℝ}
    (hH : ∀ D : WallVariation, normalFirstVariation μ D =
      H*directionalFlux E D.coordinate D.function) :
    ∃ C K ρ δ : ℝ, 0 < C ∧ 0 < K ∧ 0 < ρ ∧ ρ ≤ 1/16 ∧ 0 < δ ∧
      ∀ n : Cover, ‖n‖ = 1 → ∀ e : ℝ, 0 < e → e ≤ δ →
      ∃ η : ℝ, 0 < η ∧
      ∀ (c : ℕ → Cover) (r : ℕ → ℝ), (∀ i, 0 < r i) → Tendsto r atTop (𝓝 0) →
        (∀ᶠ i in atTop, ‖c i-cubeCenter‖ ≤ 1/16) →
      ∀ A : Set Cover, MeasurableSet A →
        Tendsto (fun i ↦ ∫ x in Metric.closedBall (0 : Cover) 1,
          |blowupCharacteristic E (c i) (r i) x-A.indicator (fun _ ↦ (1 : ℝ)) x|)
          atTop (𝓝 0) →
        (∫ x in Metric.closedBall (0 : Cover) 1,
          |A.indicator (fun _ ↦ (1 : ℝ)) x-
            (coverHalfspace n).indicator (fun _ ↦ (1 : ℝ)) x|) < η →
        ∀ᶠ i in atTop, BoundaryNormalChart E (c i) n (r i/272) e C K ρ := by
  obtain ⟨C,K,ρ,δ,hC,hK,hρ,hρs,hδ,hcharts⟩ :=
    isMinimizerAt_halfspace_L1_normal_charts hV hE hmin hcenter hμ hH
  refine ⟨C,K,ρ,δ,hC,hK,hρ,hρs,hδ,?_⟩
  intro n hn e he heδ
  obtain ⟨η,hη,hsmall⟩ := hcharts n hn e he heδ
  refine ⟨η,hη,?_⟩
  intro c r hr hrlim hc A hA hconv hclose
  have hs := hrlim.eventually (Iio_mem_nhds hη)
  have hL1 := localL1_eventually_lt_model
    (fun i ↦ measurable_blowupCharacteristic hE (c i) (r i))
    (fun i ↦ blowupCharacteristic_bound E (c i) (r i))
    (measurable_const.indicator hA) (cover_indicator_bound A)
    (measurable_const.indicator (measurableSet_coverHalfspace n))
    (cover_indicator_bound (coverHalfspace n)) hconv hclose
  filter_upwards [hc,hs,hL1] with i hci hri hL1i
  exact hsmall (c i) (r i) hci (hr i) hri hL1i

lemma ae_closedBall_imp_of_ae_ball {P : Cover → Prop} {a : Cover} {r : ℝ}
    (h : ∀ᵐ x ∂(volume : Measure Cover), x ∈ Metric.ball a r → P x) :
    ∀ᵐ x ∂(volume : Measure Cover), x ∈ Metric.closedBall a r → P x := by
  have hz : ∀ᵐ x ∂(volume : Measure Cover), x ∉ Metric.sphere a r := by
    rw [ae_iff]
    simpa only [not_not,Metric.sphere,dist_eq_norm,Set.mem_ofPred_eq] using Measure.addHaar_sphere (volume : Measure Cover) a r
  filter_upwards [h,hz] with x hx hxz hxc
  apply hx
  have hh : dist x a ≤ r := hxc
  have hn : dist x a ≠ r := hxz
  exact lt_of_le_of_ne hh hn

lemma localL1_limit_congr_ae_ball {g : ℕ → Cover → ℝ} {f F : Cover → ℝ}
    {R : ℝ} {l : Filter ℕ}
    (heq : ∀ᵐ x ∂(volume : Measure Cover), x ∈ Metric.ball (0 : Cover) R → f x = F x)
    (hconv : Tendsto (fun i ↦ ∫ x in Metric.closedBall (0 : Cover) R, |g i x-f x|) l (𝓝 0)) :
    Tendsto (fun i ↦ ∫ x in Metric.closedBall (0 : Cover) R, |g i x-F x|) l (𝓝 0) := by
  have hh := ae_closedBall_imp_of_ae_ball heq
  have he (i : ℕ) : (∫ x in Metric.closedBall (0 : Cover) R, |g i x-f x|) =
      ∫ x in Metric.closedBall (0 : Cover) R, |g i x-F x| := by
    apply setIntegral_congr_ae Metric.isClosed_closedBall.measurableSet
    filter_upwards [hh] with x hx hxb
    rw [hx hxb]
  simpa only [he] using hconv

lemma volume_real_affine_preimage_ball {A : Set Cover} (hA : MeasurableSet A)
    (p : Cover) {s : ℝ} (hs : 0 < s) (ρ : ℝ) :
    volume.real (((fun x ↦ p+s • x) ⁻¹' A) ∩ Metric.ball (0 : Cover) ρ) =
      s⁻¹^3*volume.real (A ∩ Metric.ball p (s*ρ)) := by
  have he (D : Set Cover) (hD : MeasurableSet D) (a : Cover) (r : ℝ) :
      (∫ x in Metric.ball a r, D.indicator (fun _ ↦ (1 : ℝ)) x) =
        volume.real (D ∩ Metric.ball a r) := by
    rw [integral_indicator hD,Measure.restrict_restrict hD,integral_const,smul_eq_mul,mul_one,
      Measure.real_def,Measure.restrict_apply_univ]
    rfl
  have hD : MeasurableSet ((fun x : Cover ↦ p+s • x) ⁻¹' A) :=
    hA.preimage (by fun_prop)
  rw [← he A hA p,← he _ hD 0]
  rw [integral_ball_affine_scaling _ p hs ρ]
  have hh (x : Cover) : ((fun x ↦ p+s • x) ⁻¹' A).indicator (fun _ ↦ (1 : ℝ)) x =
      A.indicator (fun _ ↦ (1 : ℝ)) (p+s • x) := rfl
  simp only [hh]
  field_simp

end CubicTorus

end
end

section

noncomputable section
open MeasureTheory Set Filter
open scoped ENNReal NNReal Topology RealInnerProductSpace
namespace CubicTorus

def ActualBoundaryGraph (E : Set Torus) (c n : Cover) (q : ℝ) : Prop :=
  ∃ a : Cover, dist a c < q/(544*4096) ∧
    ∃ g : Plane → ℝ, LipschitzWith (1/4) g ∧
      ContDiffOn ℝ 1 g (Metric.ball 0 ((q/544)/1024)) ∧
      (∀ y ∈ Metric.ball (0 : Plane) ((q/544)/1024),
        quotientMap a+quotientMap (normalGraph n g y) ∈ frontier (openRepresentative E) ∧
        ‖normalGraph n g y‖ < (q/544)/512) ∧
      (∀ x ∈ quotientMap ⁻¹' frontier (openRepresentative E) ∩ Metric.ball a ((q/544)/128),
        normalGraph n g (normalPlaneCoordinates n (x-a)) = x-a)

theorem actual_primary_fixed_scale_packets {V : ℝ} (hV : V ∈ Ioo 0 1)
    {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E)
    (hcenter : quotientMap cubeCenter ∈ frontier (openRepresentative E))
    {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) {H : ℝ}
    (hH : ∀ D : WallVariation, normalFirstVariation μ D =
      H*directionalFlux E D.coordinate D.function) :
    ∃ C K ρ δ : ℝ, 0 < C ∧ 0 < K ∧ 0 < ρ ∧ ρ ≤ 1/16 ∧ 0 < δ ∧
      ∀ n : Cover, ‖n‖ = 1 → ∀ e : ℝ, 0 < e → e ≤ δ →
      ∃ η : ℝ, 0 < η ∧
      ∀ (r : ℕ → ℝ), (∀ i, 0 < r i) → Tendsto r atTop (𝓝 0) →
      ∀ A : Set Cover, MeasurableSet A →
        Tendsto (fun i ↦ ∫ x in Metric.closedBall (0 : Cover) 2,
          |blowupCharacteristic E cubeCenter (r i) x-A.indicator (fun _ ↦ (1 : ℝ)) x|)
          atTop (𝓝 0) →
      ∀ p : Cover, ‖p‖ < 1 →
        (∀ t : ℝ, 0 < t → 0 < volume.real (A ∩ Metric.ball p t) ∧
          0 < volume.real (Aᶜ ∩ Metric.ball p t)) →
      ∀ s : ℝ, 0 < s → s ≤ 1 →
        (∫ x in Metric.closedBall (0 : Cover) 1,
          |A.indicator (fun _ ↦ (1 : ℝ)) (p+s • x)-
            (coverHalfspace n).indicator (fun _ ↦ (1 : ℝ)) x|) < η →
      ∀ᶠ i in atTop,
        ActualBoundaryGraph E (cubeCenter+r i • p) n (r i*s) ∧
        BoundaryNormalChart E (cubeCenter+r i • p) n ((r i*s)/272) e C K ρ := by
  obtain ⟨C,K,ρ,δ,hC,hK,hρ,hρs,hδ,hnormals⟩ :=
    isMinimizerAt_close_limit_fixed_scale_normals hV hE hmin hcenter hμ hH
  refine ⟨C,K,ρ,δ,hC,hK,hρ,hρs,hδ,?_⟩
  intro n hn e he heδ
  obtain ⟨ηN,hηN,hN⟩ := hnormals n hn e he heδ
  obtain ⟨ηG,hηG,hG⟩ := isMinimizerAt_close_limit_fixed_scale_graphs hV hE hmin hcenter hμ hH hn
  refine ⟨min ηN ηG,lt_min hηN hηG,?_⟩
  intro r hr hrlim A hA hconv p hp hboundary s hs hs1 hclose
  obtain ⟨k,hk⟩ := eventually_atTop.mp (hrlim.eventually (Iio_mem_nhds (by norm_num : (0:ℝ)<1/32)))
  let c : ℕ → MovingCenter.InteriorCenter := fun i ↦ ⟨cubeCenter+r (i+k) • p,by
    simp only [add_sub_cancel_left,norm_smul,Real.norm_of_nonneg (hr _).le]
    have hh := hk (i+k) (by omega)
    nlinarith [hr (i+k)]⟩
  let q : ℕ → ℝ := fun i ↦ r (i+k)*s
  have hq : ∀ i, 0 < q i := fun i ↦ mul_pos (hr _) hs
  have hqlim : Tendsto q atTop (𝓝 0) := by
    simpa only [q,Function.comp_def,zero_mul] using (hrlim.comp (tendsto_add_atTop_nat k)).mul_const s
  have hc (i : ℕ) : ‖(c i : Cover)-cubeCenter‖ ≤ 1/32 := by
    change ‖cubeCenter+r (i+k) • p-cubeCenter‖ ≤ 1/32
    rw [add_sub_cancel_left,norm_smul,Real.norm_of_nonneg (hr _).le]
    have hh := hk (i+k) (by omega)
    nlinarith [hr (i+k)]
  let D : Set Cover := (fun x ↦ p+s • x) ⁻¹' A
  have hD : MeasurableSet D := hA.preimage (by fun_prop)
  have hsub : Metric.closedBall p (s*1) ⊆ Metric.closedBall (0 : Cover) 2 := by
    intro x hx
    have hx' : ‖x-p‖ ≤ s := by simpa only [Metric.mem_closedBall,dist_eq_norm,mul_one] using hx
    have hh := norm_add_le (x-p) p
    rw [sub_add_cancel] at hh
    simpa only [Metric.mem_closedBall,dist_zero_right] using (by linarith : ‖x‖ ≤ 2)
  have hshift := localL1_affine_tendsto
    (fun i ↦ measurable_blowupCharacteristic hE cubeCenter (r i))
    (fun i ↦ blowupCharacteristic_bound E cubeCenter (r i))
    (measurable_const.indicator hA) (cover_indicator_bound A) hconv p hs hsub
  have hlim : Tendsto (fun i ↦ ∫ x in Metric.closedBall (0 : Cover) 1,
      |blowupCharacteristic E (c i) (q i) x-D.indicator (fun _ ↦ (1 : ℝ)) x|) atTop (𝓝 0) := by
    have hh := hshift.comp (tendsto_add_atTop_nat k)
    convert hh using 2
    rename_i i
    apply integral_congr_ae
    apply ae_of_all
    intro x
    change |blowupCharacteristic E (cubeCenter+r (i+k) • p) (r (i+k)*s) x-
      D.indicator (fun _ ↦ (1 : ℝ)) x| =
      |blowupCharacteristic E cubeCenter (r (i+k)) (p+s • x)-
        A.indicator (fun _ ↦ (1 : ℝ)) (p+s • x)|
    rw [blowupCharacteristic_affine]
    rfl
  have hphases (t : ℝ) (ht : 0 < t) (_ : t ≤ 1) :
      0 < volume.real (D ∩ Metric.ball (0 : Cover) t) ∧
      0 < volume.real (Dᶜ ∩ Metric.ball (0 : Cover) t) := by
    have hh := hboundary (s*t) (mul_pos hs ht)
    change 0 < volume.real (((fun x ↦ p+s • x) ⁻¹' A) ∩ Metric.ball (0 : Cover) t) ∧
      0 < volume.real (((fun x ↦ p+s • x) ⁻¹' Aᶜ) ∩ Metric.ball (0 : Cover) t)
    rw [volume_real_affine_preimage_ball hA p hs,volume_real_affine_preimage_ball hA.compl p hs]
    exact ⟨mul_pos (by positivity) hh.1,mul_pos (by positivity) hh.2⟩
  have hclose' : (∫ x in Metric.closedBall (0 : Cover) 1,
      |D.indicator (fun _ ↦ (1 : ℝ)) x-(coverHalfspace n).indicator (fun _ ↦ (1 : ℝ)) x|) < min ηN ηG := hclose
  have hgg := hG c q hq hqlim (Eventually.of_forall hc) D hD hlim hphases
    (hclose'.trans_le (min_le_right _ _))
  have hnn := hN (fun i ↦ (c i : Cover)) q hq hqlim
    (Eventually.of_forall (fun i ↦ (hc i).trans (by norm_num : (1:ℝ)/32 ≤ 1/16))) D hD hlim
    (hclose'.trans_le (min_le_left _ _))
  have hall : ∀ᶠ i in atTop,
      ActualBoundaryGraph E (cubeCenter+r (i+k) • p) n (r (i+k)*s) ∧
      BoundaryNormalChart E (cubeCenter+r (i+k) • p) n ((r (i+k)*s)/272) e C K ρ := by
    filter_upwards [hgg,hnn] with i hgi hni
    exact ⟨hgi,hni⟩
  obtain ⟨j,hj⟩ := eventually_atTop.mp hall
  refine eventually_atTop.mpr ⟨j+k,?_⟩
  intro i hi
  have hh := hj (i-k) (by omega)
  simpa only [Nat.sub_add_cancel (by omega : k ≤ i)] using hh

end CubicTorus

end
end

section

noncomputable section
open MeasureTheory Set Filter
open scoped ENNReal NNReal Topology RealInnerProductSpace
namespace CubicTorus

lemma exists_uniform_subseq_of_bounded_modulus {X Y : Type*}
    [PseudoMetricSpace X] [CompactSpace X] [MetricSpace Y] [ProperSpace Y]
    (f : ℕ → X → Y) (hc : ∀ i, Continuous (f i)) (y₀ : Y) (M : ℝ)
    (hb : ∀ i x, dist (f i x) y₀ ≤ M)
    (hm : ∀ ε : ℝ, 0 < ε → ∃ η : ℝ, 0 < η ∧
      ∀ i x y, dist x y < η → dist (f i x) (f i y) < ε) :
    ∃ (g : X → Y) (φ : ℕ → ℕ), Continuous g ∧ StrictMono φ ∧
      TendstoUniformly (fun i ↦ f (φ i)) g atTop := by
  let F : ℕ → BoundedContinuousFunction X Y := fun i ↦
    BoundedContinuousFunction.mkOfCompact ⟨f i,hc i⟩
  have heq : Equicontinuous ((↑) : range F → X → Y) := by
    apply UniformEquicontinuous.equicontinuous
    rw [Metric.uniformEquicontinuous_iff]
    intro ε hε
    obtain ⟨η,hη,hηm⟩ := hm ε hε
    refine ⟨η,hη,?_⟩
    intro x y hxy
    rintro ⟨_,i,rfl⟩
    exact hηm i x y hxy
  have hcpt := BoundedContinuousFunction.arzela_ascoli
    (Metric.closedBall y₀ M) (isCompact_closedBall y₀ M) (range F)
    (by rintro _ x ⟨i,rfl⟩; exact hb i x) heq
  obtain ⟨g,_,φ,hφ,hconv⟩ := hcpt.tendsto_subseq (fun i ↦ subset_closure (mem_range_self i))
  exact ⟨g,φ,g.continuous,hφ,BoundedContinuousFunction.tendsto_iff_tendstoUniformly.mp hconv⟩

def normalGraphDerivative (n ν : Cover) : Plane →L[ℝ] ℝ :=
  (⟪ν,n⟫)⁻¹ • (-((innerSL ℝ ν).comp (normalPlaneLinearIsometry n).toContinuousLinearMap))

lemma transverse_inner_lower {n ν : Cover} (hn : ‖n‖ = 1) (hν : ‖n-ν‖ ≤ 1/2) :
    1/2 ≤ ⟪ν,n⟫ := by
  have hh := abs_real_inner_le_norm (n-ν) n
  rw [inner_sub_left,real_inner_self_eq_norm_sq,hn,mul_one] at hh
  have hl := (abs_le.mp hh).2
  norm_num at hl
  linarith

lemma normalGraphDerivative_continuousOn {n : Cover} (hn : ‖n‖ = 1) :
    ContinuousOn (normalGraphDerivative n) (Metric.closedBall n (1/2)) := by
  have hi : ContinuousOn (fun ν : Cover ↦ (⟪ν,n⟫)⁻¹) (Metric.closedBall n (1/2)) := by
    apply (continuous_id.inner continuous_const).continuousOn.inv₀
    intro ν hν
    have hnorm : ‖n-ν‖ ≤ 1/2 := by simpa only [Metric.mem_closedBall,dist_eq_norm,norm_sub_rev] using hν
    exact ne_of_gt (lt_of_lt_of_le (by norm_num : (0:ℝ)<1/2) (transverse_inner_lower hn hnorm))
  exact hi.smul ((((innerSL ℝ).continuous.continuousOn).clm_comp continuousOn_const).neg)

end CubicTorus

end
end

section

noncomputable section
open MeasureTheory Set Filter
open scoped ENNReal NNReal Topology RealInnerProductSpace
namespace CubicTorus

def rescaledActualBoundary (E : Set Torus) (c : Cover) (q : ℝ) : Set Cover :=
  (fun x ↦ quotientMap (c+q • x)) ⁻¹' frontier (openRepresentative E)

end CubicTorus
end
end
end

end OAI