lean/OAI/Geometry/CubicTorus/Estimates/BVPlanarLocalModels.lean

import Mathlib
import OAI.Geometry.CubicTorus.Regularity.BVPlanarAngularChart

namespace OAI

section

section

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

lemma planar_cone_rotation {C : Set Plane}
    (hc : ∀ t : ℝ, 1 ≤ t → ∀ᵐ y : Plane ∂volume,
      y ∈ Metric.ball (0 : Plane) (1/16) → (t⁻¹ • y ∈ C ↔ y ∈ C))
    (R : Plane ≃ₗᵢ[ℝ] Plane) :
    ∀ t : ℝ, 1 ≤ t → ∀ᵐ y : Plane ∂volume,
      y ∈ Metric.ball (0 : Plane) (1/16) → (t⁻¹ • y ∈ R ⁻¹' C ↔ y ∈ R ⁻¹' C) := by
  intro t ht
  filter_upwards [R.measurePreserving.quasiMeasurePreserving.ae (hc t ht)] with y hy hyb
  have hRy : R y ∈ Metric.ball (0 : Plane) (1/16) := by
    simpa only [Metric.mem_ball,dist_zero_right,R.norm_map] using hyb
  simpa only [Set.mem_preimage,R.map_smul] using hy hRy

lemma planar_directional_bv_rotation {C : Set Plane} {K : ℝ}
    (hbv : ∀ φ : Plane → ℝ, ContDiff ℝ (⊤ : ℕ∞) φ →
      tsupport φ ⊆ Metric.closedBall (0 : Plane) (1/32) → (∀ y, |φ y| ≤ 1) →
      ∀ u : Plane, ‖u‖ = 1 → |∫ y in C, fderiv ℝ φ y u| ≤ K)
    (R : Plane ≃ₗᵢ[ℝ] Plane) :
    ∀ φ : Plane → ℝ, ContDiff ℝ (⊤ : ℕ∞) φ →
      tsupport φ ⊆ Metric.closedBall (0 : Plane) (1/32) → (∀ y, |φ y| ≤ 1) →
      ∀ u : Plane, ‖u‖ = 1 → |∫ y in R ⁻¹' C, fderiv ℝ φ y u| ≤ K := by
  intro φ hφ hs hb u hu
  let ψ : Plane → ℝ := φ ∘ R.symm
  have hψ : ContDiff ℝ (⊤ : ℕ∞) ψ := hφ.comp R.symm.toContinuousLinearEquiv.contDiff
  have hsψ : tsupport ψ ⊆ Metric.closedBall (0 : Plane) (1/32) := by
    rw [show ψ = φ ∘ R.symm.toHomeomorph from rfl,tsupport_comp_eq_preimage]
    intro y hy
    have hh := hs hy
    simp only [Metric.mem_closedBall,dist_zero_right] at hh
    change ‖R.symm y‖ ≤ 1/32 at hh
    simpa only [Metric.mem_closedBall,dist_zero_right,R.symm.norm_map] using hh
  have hd (y : Plane) : fderiv ℝ ψ (R y) (R u) = fderiv ℝ φ y u := by
    have he := ((hφ.differentiable (by simp)) (R.symm (R y))).hasFDerivAt.comp (R y)
      R.symm.toContinuousLinearEquiv.hasFDerivAt
    have h := congrArg (fun A : Plane →L[ℝ] ℝ ↦ A (R u)) he.fderiv
    change fderiv ℝ ψ (R y) (R u) = fderiv ℝ φ (R.symm (R y)) (R.symm (R u)) at h
    simpa only [LinearIsometryEquiv.symm_apply_apply] using h
  have he := R.measurePreserving.setIntegral_preimage_emb R.toHomeomorph.toMeasurableEquiv.measurableEmbedding
    (fun y ↦ fderiv ℝ ψ y (R u)) C
  simp_rw [hd] at he
  rw [he]
  exact hbv ψ hψ hsψ (fun y ↦ hb _) (R u) (by simpa using hu)

theorem planar_cone_finite_angular_transitions_rotated {C : Set Plane} (hC : MeasurableSet C)
    (hc : ∀ t : ℝ, 1 ≤ t → ∀ᵐ y : Plane ∂volume,
      y ∈ Metric.ball (0 : Plane) (1/16) → (t⁻¹ • y ∈ C ↔ y ∈ C))
    {K : ℝ} (hK : 0 ≤ K)
    (hbv : ∀ φ : Plane → ℝ, ContDiff ℝ (⊤ : ℕ∞) φ →
      tsupport φ ⊆ Metric.closedBall (0 : Plane) (1/32) → (∀ y, |φ y| ≤ 1) →
      ∀ u : Plane, ‖u‖ = 1 → |∫ y in C, fderiv ℝ φ y u| ≤ K)
    (R : Plane ≃ₗᵢ[ℝ] Plane) :
    ∃ (a b : ℝ) (D : Set ℝ), 0 < a ∧ a < b ∧ MeasurableSet D ∧
      (∀ᵐ z : ℝ × ℝ ∂volume, z.1 ∈ Ioo a b → z.2 ∈ Ioo (-1 : ℝ) 1 →
        (R (planarWedgeChart z) ∈ C ↔ z.2 ∈ D)) ∧
      (Icc (-(1/4 : ℝ)) (1/4) ∩ angularEssentialBoundary D).Finite :=
  planar_cone_finite_angular_transitions (hC.preimage R.continuous.measurable)
    (planar_cone_rotation hc R) hK (planar_directional_bv_rotation hbv R)

end CubicTorus

end
end

section

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

lemma ae_not_phase_of_inter_null {A D : Set ℝ} (h : volume (A ∩ D) = 0) :
    ∀ᵐ t : ℝ ∂volume, t ∈ A → t ∉ D :=
  (measure_eq_zero_iff_ae_notMem.mp h).mono (fun _ ht ha hd ↦ ht ⟨ha,hd⟩)

lemma ae_phase_of_inter_compl_null {A D : Set ℝ} (h : volume (A ∩ Dᶜ) = 0) :
    ∀ᵐ t : ℝ ∂volume, t ∈ A → t ∈ D := by
  filter_upwards [ae_not_phase_of_inter_null h] with t ht ha
  exact not_not.mp (ht ha)

theorem angular_finite_local_model {D : Set ℝ} (hD : MeasurableSet D)
    (hfin : (Icc (-(1/4 : ℝ)) (1/4) ∩ angularEssentialBoundary D).Finite) :
    ∃ (δ : ℝ) (S : Set ℝ), 0 < δ ∧ δ ≤ 1 ∧
      (S = ∅ ∨ S = univ ∨ S = Ioi (0 : ℝ) ∨ S = Iio (0 : ℝ)) ∧
      ∀ᵐ t : ℝ ∂volume, |t| < δ → (t ∈ D ↔ t ∈ S) := by
  have shrink {δ : ℝ} (hδ : 0 < δ) (S : Set ℝ)
      (hS : S = ∅ ∨ S = univ ∨ S = Ioi (0 : ℝ) ∨ S = Iio (0 : ℝ))
      (h : ∀ᵐ t : ℝ ∂volume, |t| < δ → (t ∈ D ↔ t ∈ S)) :
      ∃ (δ : ℝ) (S : Set ℝ), 0 < δ ∧ δ ≤ 1 ∧
        (S = ∅ ∨ S = univ ∨ S = Ioi (0 : ℝ) ∨ S = Iio (0 : ℝ)) ∧
        ∀ᵐ t : ℝ ∂volume, |t| < δ → (t ∈ D ↔ t ∈ S) := by
    exact ⟨min δ 1,S,lt_min hδ (by norm_num),min_le_right _ _,hS,
      h.mono (fun _ ht hb ↦ ht (hb.trans_le (min_le_left _ _)))⟩
  by_cases hx : (0 : ℝ) ∈ angularEssentialBoundary D
  · obtain ⟨δ,hδ,he⟩ := finite_angular_transition_is_jump hD hfin
      (show (0 : ℝ) ∈ Ioo (-(1/4 : ℝ)) (1/4) by constructor <;> norm_num) hx
    have hn : ∀ᵐ t : ℝ ∂volume, t ≠ 0 := by rw [ae_iff]; simp
    rcases he with he|he
    · apply shrink hδ (Ioi 0) (Or.inr (Or.inr (Or.inl rfl)))
      filter_upwards [ae_not_phase_of_inter_null he.1,ae_phase_of_inter_compl_null he.2,hn]
        with t hL hR ht hb
      have hl := (abs_lt.mp hb).1
      have hr := (abs_lt.mp hb).2
      rcases lt_or_gt_of_ne ht with ht|ht
      · have hh := hL (show t ∈ Ioo (0-δ) 0 by constructor <;> linarith)
        simp only [Set.mem_Ioi]
        exact iff_of_false hh (not_lt_of_ge ht.le)
      · have hh := hR (show t ∈ Ioo 0 (0+δ) by constructor <;> linarith)
        exact iff_of_true hh ht
    · apply shrink hδ (Iio 0) (Or.inr (Or.inr (Or.inr rfl)))
      filter_upwards [ae_phase_of_inter_compl_null he.1,ae_not_phase_of_inter_null he.2,hn]
        with t hL hR ht hb
      have hl := (abs_lt.mp hb).1
      have hr := (abs_lt.mp hb).2
      rcases lt_or_gt_of_ne ht with ht|ht
      · have hh := hL (show t ∈ Ioo (0-δ) 0 by constructor <;> linarith)
        exact iff_of_true hh ht
      · have hh := hR (show t ∈ Ioo 0 (0+δ) by constructor <;> linarith)
        simp only [Set.mem_Iio]
        exact iff_of_false hh (not_lt_of_ge ht.le)
  · change ¬ ∀ δ : ℝ, 0 < δ → 0 < volume (D ∩ Metric.ball 0 δ) ∧
      0 < volume (Dᶜ ∩ Metric.ball 0 δ) at hx
    push Not at hx
    obtain ⟨δ,hδ,hnull⟩ := hx
    by_cases hfirst : volume (D ∩ Metric.ball (0 : ℝ) δ) = 0
    · apply shrink hδ ∅ (Or.inl rfl)
      have he : volume (Metric.ball (0 : ℝ) δ ∩ D) = 0 := by
        rw [inter_comm]; exact hfirst
      filter_upwards [ae_not_phase_of_inter_null he] with t ht hb
      exact iff_of_false (ht (by simpa only [Metric.mem_ball,Real.dist_eq,sub_zero] using hb))
        (Set.notMem_empty t)
    · have hnull := hnull (lt_of_le_of_ne bot_le (Ne.symm hfirst))
      apply shrink hδ univ (Or.inr (Or.inl rfl))
      have he : volume (Metric.ball (0 : ℝ) δ ∩ Dᶜ) = 0 := by
        rw [inter_comm]; exact le_antisymm hnull bot_le
      filter_upwards [ae_phase_of_inter_compl_null he] with t ht hb
      exact iff_of_true (ht (by simpa only [Metric.mem_ball,Real.dist_eq,sub_zero] using hb))
        (Set.mem_univ t)

end CubicTorus

end
end

section

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

lemma triangular_inv_mul_quasiMeasurePreserving :
    Measure.QuasiMeasurePreserving (fun z : ℝ × ℝ ↦ (z.1,z.1⁻¹*z.2)) volume volume := by
  have hm : Measurable (fun z : ℝ × ℝ ↦ (z.1,z.1⁻¹*z.2)) :=
    measurable_fst.prodMk (measurable_fst.inv.mul measurable_snd)
  refine ⟨hm,Measure.AbsolutelyContinuous.mk (fun S hS hS0 ↦ ?_)⟩
  rw [Measure.map_apply hm hS,Measure.volume_eq_prod,Measure.prod_apply (hm hS)]
  have hnull : ∀ᵐ x : ℝ ∂volume, (volume : Measure ℝ) (Prod.mk x ⁻¹' S) = 0 := by
    apply (lintegral_eq_zero_iff (measurable_measure_prodMk_left hS)).mp
    simpa only [← Measure.prod_apply hS,← Measure.volume_eq_prod] using hS0
  have hn : ∀ᵐ x : ℝ ∂volume, x ≠ 0 := by rw [ae_iff]; simp
  change (∫⁻ x : ℝ, (volume : Measure ℝ) ((fun y : ℝ ↦ (x,x⁻¹*y)) ⁻¹' S)) = 0
  rw [lintegral_congr_ae (show (fun x : ℝ ↦ (volume : Measure ℝ)
      ((fun y : ℝ ↦ (x,x⁻¹*y)) ⁻¹' S)) =ᵐ[volume] 0 from ?_)]
  · simp
  filter_upwards [hnull,hn] with x hx hx0
  exact (Measure.quasiMeasurePreserving_smul (volume : Measure ℝ) (inv_ne_zero hx0)).preimage_null hx

def planarWedgeCoordinates (y : Plane) : ℝ × ℝ :=
  ((planeProductCoordinates y).1,(planeProductCoordinates y).1⁻¹*(planeProductCoordinates y).2)

lemma planarWedgeCoordinates_quasiMeasurePreserving :
    Measure.QuasiMeasurePreserving planarWedgeCoordinates volume volume :=
  triangular_inv_mul_quasiMeasurePreserving.comp
    planeProductCoordinates_measurePreserving.quasiMeasurePreserving

lemma planarWedgeChart_coordinates {y : Plane} (hy : (planeProductCoordinates y).1 ≠ 0) :
    planarWedgeChart (planarWedgeCoordinates y) = y := by
  unfold planarWedgeCoordinates planarWedgeChart
  simp only [mul_inv_cancel_left₀ hy,Prod.mk.eta,ContinuousLinearEquiv.symm_apply_apply]

lemma planarWedgeCoordinates_chart {s t : ℝ} (hs : s ≠ 0) :
    planarWedgeCoordinates (planarWedgeChart (s,t)) = (s,t) := by
  simp only [planarWedgeCoordinates,planarWedgeChart,ContinuousLinearEquiv.apply_symm_apply,
    inv_mul_cancel_left₀ hs]

theorem planar_cone_local_slope_model {C : Set Plane} (hC : MeasurableSet C)
    (hc : ∀ t : ℝ, 1 ≤ t → ∀ᵐ y : Plane ∂volume,
      y ∈ Metric.ball (0 : Plane) (1/16) → (t⁻¹ • y ∈ C ↔ y ∈ C))
    {K : ℝ} (hK : 0 ≤ K)
    (hbv : ∀ φ : Plane → ℝ, ContDiff ℝ (⊤ : ℕ∞) φ →
      tsupport φ ⊆ Metric.closedBall (0 : Plane) (1/32) → (∀ y, |φ y| ≤ 1) →
      ∀ u : Plane, ‖u‖ = 1 → |∫ y in C, fderiv ℝ φ y u| ≤ K)
    (R : Plane ≃ₗᵢ[ℝ] Plane) :
    ∃ (a b δ : ℝ) (S : Set ℝ), 0 < a ∧ a < b ∧ 0 < δ ∧ δ ≤ 1 ∧
      (S = ∅ ∨ S = univ ∨ S = Ioi (0 : ℝ) ∨ S = Iio (0 : ℝ)) ∧
      ∀ᵐ y : Plane ∂volume,
        (planarWedgeCoordinates (R.symm y)).1 ∈ Ioo a b →
        |(planarWedgeCoordinates (R.symm y)).2| < δ →
        (y ∈ C ↔ (planarWedgeCoordinates (R.symm y)).2 ∈ S) := by
  obtain ⟨a,b,D,ha,hab,hD,hprod,hfin⟩ :=
    planar_cone_finite_angular_transitions_rotated hC hc hK hbv R
  obtain ⟨δ,S,hδ,hδ1,hS,hmodel⟩ := angular_finite_local_model hD hfin
  have hmodP : ∀ᵐ z : ℝ × ℝ ∂volume, |z.2| < δ → (z.2 ∈ D ↔ z.2 ∈ S) := by
    simpa only [Measure.volume_eq_prod] using
      (MeasureTheory.Measure.quasiMeasurePreserving_snd (μ := (volume : Measure ℝ))).ae hmodel
  have hboth : ∀ᵐ z : ℝ × ℝ ∂volume, z.1 ∈ Ioo a b → |z.2| < δ →
      (R (planarWedgeChart z) ∈ C ↔ z.2 ∈ S) := by
    filter_upwards [hprod,hmodP] with z hz hm hz1 hz2
    have hz2' : z.2 ∈ Ioo (-1 : ℝ) 1 := by
      have hh := abs_lt.mp hz2
      constructor <;> linarith [hh.1,hh.2]
    exact (hz hz1 hz2').trans (hm hz2)
  have hq := planarWedgeCoordinates_quasiMeasurePreserving.comp
    R.symm.measurePreserving.quasiMeasurePreserving
  refine ⟨a,b,δ,S,ha,hab,hδ,hδ1,hS,?_⟩
  filter_upwards [hq.ae hboth] with y hy hy1 hy2
  have hnot : (planeProductCoordinates (R.symm y)).1 ≠ 0 :=
    ne_of_gt (ha.trans hy1.1)
  have he : R (planarWedgeChart (planarWedgeCoordinates (R.symm y))) = y := by
    rw [planarWedgeChart_coordinates hnot,R.apply_symm_apply]
  have hh := hy hy1 hy2
  simp only [Function.comp_apply] at hh
  rwa [he] at hh

end CubicTorus

end
end

section

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

lemma planeProductCoordinates_apply (y : Plane) : planeProductCoordinates y = (y 0,y 1) := by
  simp [planeProductCoordinates,Complex.orthonormalBasisOneI]

lemma planeProductCoordinates_symm_apply (z : ℝ × ℝ) :
    planeProductCoordinates.symm z = WithLp.toLp 2 ![z.1,z.2] := by
  apply planeProductCoordinates.injective
  rw [ContinuousLinearEquiv.apply_symm_apply,planeProductCoordinates_apply]
  rfl

def coverPlaneCoordinates : Cover ≃L[ℝ] ℝ × Plane :=
  coverPrismCoordinates.trans ((ContinuousLinearEquiv.refl ℝ ℝ).prodCongr planeProductCoordinates.symm)

lemma coverPlaneCoordinates_apply (x : Cover) :
    coverPlaneCoordinates x = (x 0,WithLp.toLp 2 ![x 1,x 2]) := by
  simp [coverPlaneCoordinates,coverPrismCoordinates_apply,planeProductCoordinates_symm_apply]

lemma coverPlaneCoordinates_norm_sq (x : Cover) :
    ‖x‖^2 = (coverPlaneCoordinates x).1^2 + ‖(coverPlaneCoordinates x).2‖^2 := by
  rw [coverPlaneCoordinates_apply,EuclideanSpace.real_norm_sq_eq,
    EuclideanSpace.real_norm_sq_eq,Fin.sum_univ_three,Fin.sum_univ_two]
  simp only [Matrix.cons_val_zero,Matrix.cons_val_one]
  ring

def coverPlaneRotationCLE (R : Plane ≃ₗᵢ[ℝ] Plane) : Cover ≃L[ℝ] Cover :=
  (coverPlaneCoordinates.trans
    ((ContinuousLinearEquiv.refl ℝ ℝ).prodCongr R.toContinuousLinearEquiv)).trans coverPlaneCoordinates.symm

lemma coverPlaneRotationCLE_coordinates (R : Plane ≃ₗᵢ[ℝ] Plane) (x : Cover) :
    coverPlaneCoordinates (coverPlaneRotationCLE R x) =
      ((coverPlaneCoordinates x).1,R (coverPlaneCoordinates x).2) := by
  simp [coverPlaneRotationCLE]

def coverPlaneRotation (R : Plane ≃ₗᵢ[ℝ] Plane) : Cover ≃ₗᵢ[ℝ] Cover :=
  { (coverPlaneRotationCLE R).toLinearEquiv with
    norm_map' := by
      intro x
      change ‖coverPlaneRotationCLE R x‖ = ‖x‖
      apply (sq_eq_sq₀ (norm_nonneg _) (norm_nonneg _)).mp
      rw [coverPlaneCoordinates_norm_sq,coverPlaneCoordinates_norm_sq,
        coverPlaneRotationCLE_coordinates,R.norm_map] }

def swapPrismPlane : Cover ≃ₗᵢ[ℝ] Cover :=
  LinearIsometryEquiv.piLpCongrLeft 2 ℝ ℝ (Equiv.swap (1 : Fin 3) 2)

lemma swapPrismPlane_apply (x : Cover) :
    swapPrismPlane x = WithLp.toLp 2 ![x 0,x 2,x 1] := by
  ext i
  fin_cases i <;> norm_num [swapPrismPlane,LinearIsometryEquiv.piLpCongrLeft,Equiv.swap_apply_def,Fin.ext_iff]

def prismFrame (n : Cover) (R : Plane ≃ₗᵢ[ℝ] Plane) : Cover ≃ₗᵢ[ℝ] Cover :=
  (swapPrismPlane.trans (coverPlaneRotation R)).trans (normalRotation n)

lemma normalColumnChart_zero_coordinates (n : Cover) (x : Cover) :
    normalColumnChart 0 n (coverPlaneCoordinates x) = normalRotation n x := by
  rw [coverPlaneCoordinates_apply]
  change 0 + normalProductChart n (x 0,WithLp.ofLp (WithLp.toLp 2 ![x 1,x 2])) = _
  rw [zero_add,normalProductChart_apply]
  congr 1
  ext i
  fin_cases i <;> rfl

lemma prismFrame_apply (n : Cover) (R : Plane ≃ₗᵢ[ℝ] Plane) (x : Cover) :
    prismFrame n R x = normalColumnChart 0 n
      (x 0,R (planeProductCoordinates.symm (x 2,x 1))) := by
  change normalRotation n (coverPlaneRotationCLE R (swapPrismPlane x)) = _
  rw [← normalColumnChart_zero_coordinates,coverPlaneRotationCLE_coordinates,
    swapPrismPlane_apply,coverPlaneCoordinates_apply,planeProductCoordinates_symm_apply]
  rfl

lemma prismColumnCoordinates_measurePreserving :
    MeasurePreserving (fun x : Cover ↦ (x 0,planeProductCoordinates.symm (x 2,x 1))) volume volume := by
  have hp := (MeasurePreserving.id (volume : Measure ℝ)).prod
    ((planeProductCoordinates_measurePreserving.symm
      planeProductCoordinates.toHomeomorph.toMeasurableEquiv).comp
        (Measure.measurePreserving_swap (μ := (volume : Measure ℝ)) (ν := (volume : Measure ℝ))))
  have hh := hp.comp coverPrismCoordinates_measurePreserving
  convert! hh using 1

end CubicTorus

end
end

section

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

lemma finiteMeasure_real_open_le_of_eventually_le {X : Type*} [MeasurableSpace X]
    [TopologicalSpace X] [HasOuterApproxClosed X] [OpensMeasurableSpace X]
    {l : Filter ℕ} [NeBot l] {μ : ℕ → FiniteMeasure X} {ν : FiniteMeasure X}
    (hlim : Tendsto μ l (𝓝 ν)) {s : Set X} (hs : IsOpen s)
    {u : ℕ → ℝ} {L : ℝ} (hu : Tendsto u l (𝓝 L))
    (hb : ∀ᶠ i in l, (μ i : Measure X).real s ≤ u i) :
    (ν : Measure X).real s ≤ L := by
  have hm : Tendsto (fun i ↦ (μ i : Measure X).real univ) l
      (𝓝 ((ν : Measure X).real univ)) :=
    NNReal.continuous_coe.continuousAt.tendsto.comp (FiniteMeasure.continuous_mass.tendsto ν |>.comp hlim)
  have he := ENNReal.continuous_ofReal.continuousAt.tendsto.comp (hm.sub hu)
  have hbd : ∀ᶠ i in l, ENNReal.ofReal ((μ i : Measure X).real univ-u i) ≤
      (μ i : Measure X) sᶜ := by
    filter_upwards [hb] with i hi
    rw [← ENNReal.ofReal_toReal (measure_ne_top (μ i : Measure X) sᶜ)]
    apply ENNReal.ofReal_le_ofReal
    change _ ≤ (μ i : Measure X).real sᶜ
    rw [measureReal_compl hs.measurableSet]
    linarith
  have hh : ENNReal.ofReal ((ν : Measure X).real univ-L) ≤ (ν : Measure X) sᶜ := by
    rw [← he.limsup_eq]
    exact (limsup_le_limsup hbd).trans
      (FiniteMeasure.limsup_measure_closed_le_of_tendsto hlim hs.isClosed_compl)
  rw [← ENNReal.ofReal_toReal (measure_ne_top (ν : Measure X) sᶜ)] at hh
  have hreal := (ENNReal.ofReal_le_ofReal_iff ENNReal.toReal_nonneg).mp hh
  change _ ≤ (ν : Measure X).real sᶜ at hreal
  rw [measureReal_compl hs.measurableSet] at hreal
  linarith

theorem moving_blowup_normal_mass_le_competitor {V : ℝ} (hV : V ∈ Ioo 0 1)
    {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E)
    {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ)
    (c : ℕ → MovingCenter.InteriorCenter) (r : ℕ → ℝ) (hr : ∀ i, 0 < r i)
    {l : Filter ℕ} [NeBot l] (hrlim : Tendsto r l (𝓝 0))
    {A B : Set Cover} (hA : MeasurableSet A) (hB : MeasurableSet B)
    (hconv : Tendsto (fun i ↦ ∫ x in Metric.closedBall (0 : Cover) 1,
      |blowupCharacteristic E (c i) (r i) x-A.indicator (fun _ ↦ (1 : ℝ)) x|)
        l (𝓝 0))
    {ν : FiniteMeasure BlowupNormalBundle}
    (hν : Tendsto (fun i ↦ blowupNormalMeasure μ (c i) (r i) 2) l (𝓝 ν))
    {a b L : ℝ} (ha : 0 < a) (hab : a < b) (hb1 : b ≤ 1) (hL : 0 ≤ L)
    (hper : coverLocalPerimeter B (Metric.closedBall (0 : Cover) b) ≤ ENNReal.ofReal L)
    (hAB : A ∆ B ⊆ Metric.ball (0 : Cover) a) :
    (ν : Measure BlowupNormalBundle).real {z | z.1 ∈ Metric.ball (0 : Cover) a} ≤ L := by
  obtain ⟨η,C,hη,_,hcomp⟩ := MovingCenter.isMinimizerAt_scaled_set_replacement hV hE hmin hμ
  obtain ⟨K,_,hK⟩ := smoothTransition_exists_deriv_bound
  let D : ℕ → ℝ := fun i ↦ ∫ x in Metric.closedBall (0 : Cover) 1,
    |blowupCharacteristic E (c i) (r i) x-A.indicator (fun _ ↦ (1 : ℝ)) x|
  have hsmall : ∀ᶠ i in l, r i < 3/8 ∧ r i*b < 1/4 ∧ (r i*b)^3*(Real.pi*8/3) < η := by
    have hs1 : Tendsto (fun i ↦ r i*b) l (𝓝 0) := by simpa using hrlim.mul_const b
    have hs2 : Tendsto (fun i ↦ (r i*b)^3*(Real.pi*8/3)) l (𝓝 0) := by
      simpa using (hs1.pow 3).mul_const (Real.pi*8/3)
    exact (hrlim.eventually (gt_mem_nhds (by norm_num : (0 : ℝ)<3/8))).and
      ((hs1.eventually (gt_mem_nhds (by norm_num : (0 : ℝ)<1/4))).and
        (hs2.eventually (gt_mem_nhds hη)))
  have hlim : Tendsto (fun i ↦ L+2*K*b*(D i+r i)/(b^2-a^2)+C*r i*b^3) l (𝓝 L) := by
    have hh := ((tendsto_const_nhds (x := L)).add
      (((tendsto_const_nhds (x := 2*K*b)).mul (hconv.add hrlim)).div_const (b^2-a^2))).add
        (((tendsto_const_nhds (x := C)).mul hrlim).mul_const (b^3))
    simpa only [zero_add,mul_zero,zero_mul,zero_div,add_zero] using hh
  apply finiteMeasure_real_open_le_of_eventually_le hν
    (Metric.isOpen_ball.preimage continuous_fst) hlim
  filter_upwards [hsmall] with i hi
  change (blowupNormalMeasure μ (c i) (r i) 2 : Measure BlowupNormalBundle).real
    {z | z.1 ∈ Metric.ball (0 : Cover) a} ≤ _
  rw [blowupNormalMeasure_ball μ (c i) (hr i) (by linarith : a ≤ 2),
    cellBallMass_eq_spatialNormalMeasure μ (c i) (r i*a)
      ((Metric.ball_subset_closedBall.trans (Metric.closedBall_subset_closedBall (by nlinarith [hr i]))).trans
        (MovingCenter.closedBall_interior hi.1))]
  have herr : (∫ x in Metric.ball (0 : Cover) b,
      |blowupCharacteristic E (c i) (r i) x-A.indicator (fun _ ↦ (1 : ℝ)) x|) < D i+r i := by
    have hm := setIntegral_mono_set (blowup_error_integrable hE hA (c i) (r i) 1)
      (ae_of_all _ fun x ↦ abs_nonneg _)
      ((Metric.ball_subset_closedBall.trans (Metric.closedBall_subset_closedBall hb1)).eventuallyLE)
    exact lt_of_le_of_lt hm (lt_add_of_pos_right _ (hr i))
  have hh := hcomp (c i) A B hA hB a b L K (r i) (D i+r i) ha hab (hr i)
    hi.2.1 hi.2.2 hL hK hper hAB herr
  calc
    _ ≤ (r i)⁻¹^2*( (r i)^2*(L+2*K*b*(D i+r i)/(b^2-a^2))+C*(r i*b)^3) :=
      mul_le_mul_of_nonneg_left hh (sq_nonneg _)
    _ = _ := by field_simp [(hr i).ne']

end CubicTorus

end
end

section

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

lemma normalMeasure_ball_le_of_smaller {ν : Measure BlowupNormalBundle} {b : ℝ}
    (hb : 0 < b) {P : ℝ≥0∞}
    (h : ∀ a : ℝ, 0 < a → a < b → ν {z | z.1 ∈ Metric.ball (0 : Cover) a} ≤ P) :
    ν {z | z.1 ∈ Metric.ball (0 : Cover) b} ≤ P := by
  let q : ℕ → ℝ := fun i ↦ b-b/((i : ℝ)+1)
  let S : ℕ → Set BlowupNormalBundle := fun i ↦ {z | z.1 ∈ Metric.ball (0 : Cover) (q i)}
  have hq : Monotone q := by
    intro i j hij
    dsimp [q]
    have hh : (i : ℝ) ≤ j := Nat.cast_le.mpr hij
    apply sub_le_sub_left
    exact div_le_div_of_nonneg_left hb.le (by positivity) (by linarith)
  have hS : Monotone S := fun i j hij z hz ↦ Metric.ball_subset_ball (hq hij) hz
  have hlim : Tendsto q atTop (𝓝 b) := by
    simpa [q,div_eq_mul_inv] using (tendsto_const_nhds (x := b)).sub
      ((tendsto_const_nhds (x := b)).mul tendsto_one_div_add_atTop_nhds_zero_nat)
  have he : (⋃ i, S i) = {z | z.1 ∈ Metric.ball (0 : Cover) b} := by
    ext z
    constructor
    · intro hz
      obtain ⟨i,hi⟩ := mem_iUnion.mp hz
      apply Metric.ball_subset_ball (show q i ≤ b from ?_) hi
      dsimp [q]
      exact sub_le_self _ (by positivity)
    · intro hz
      have hh : ‖z.1‖ < b := by simpa only [mem_ofPred_eq,Metric.mem_ball,dist_zero_right] using hz
      obtain ⟨i,hi⟩ := (hlim.eventually (lt_mem_nhds hh)).exists
      exact mem_iUnion.mpr ⟨i,by simpa only [S,mem_ofPred_eq,Metric.mem_ball,dist_zero_right] using hi⟩
  rw [← he,hS.measure_iUnion]
  apply iSup_le
  intro i
  by_cases hi : 0 < q i
  · exact h (q i) hi (by dsimp [q]; exact sub_lt_self _ (by positivity))
  · have hz : S i = ∅ := by
      ext z
      simp only [S,Metric.mem_ball,dist_zero_right,mem_ofPred_eq,mem_empty_iff_false,iff_false]
      exact not_lt.mpr ((not_lt.mp hi).trans (norm_nonneg _))
    rw [hz,measure_empty]
    exact bot_le

theorem moving_blowup_perimeter_eq_normal_ball {V : ℝ} (hV : V ∈ Ioo 0 1)
    {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E)
    {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ)
    (c : ℕ → MovingCenter.InteriorCenter) (r : ℕ → ℝ) (hr : ∀ i, 0 < r i)
    {l : Filter ℕ} [NeBot l] (hrlim : Tendsto r l (𝓝 0))
    {A : Set Cover} (hA : MeasurableSet A)
    (hconv : Tendsto (fun i ↦ ∫ x in Metric.closedBall (0 : Cover) 1,
      |blowupCharacteristic E (c i) (r i) x-A.indicator (fun _ ↦ (1 : ℝ)) x|) l (𝓝 0))
    {ν : FiniteMeasure BlowupNormalBundle}
    (hν : Tendsto (fun i ↦ blowupNormalMeasure μ (c i) (r i) 2) l (𝓝 ν))
    (hflux : ∀ F : Cover → Cover, ContDiff ℝ (⊤ : ℕ∞) F →
      tsupport F ⊆ Metric.closedBall (0 : Cover) 1 →
      (∫ z, ⟪(z.2 : Cover),F z.1⟫ ∂(ν : Measure BlowupNormalBundle)) = ∫ x in A, divergence F x)
    {b : ℝ} (hb : 0 < b) (hb1 : b ≤ 1) :
    coverLocalPerimeter A (Metric.ball (0 : Cover) b) =
      (ν : Measure BlowupNormalBundle) {z | z.1 ∈ Metric.ball (0 : Cover) b} := by
  have hup := coverLocalPerimeter_le_normal Metric.isOpen_ball.measurableSet
    (Metric.ball_subset_closedBall.trans (Metric.closedBall_subset_closedBall hb1)) hflux
  have hfin : coverLocalPerimeter A (Metric.ball (0 : Cover) b) ≠ ⊤ :=
    ne_top_of_le_ne_top (measure_ne_top (ν : Measure BlowupNormalBundle) _) hup
  let L : ℝ := (coverLocalPerimeter A (Metric.ball (0 : Cover) b)).toReal
  have hL := ENNReal.ofReal_toReal hfin
  apply le_antisymm hup
  apply normalMeasure_ball_le_of_smaller hb
  intro a ha hab
  let d : ℝ := (a+b)/2
  have had : a < d := by dsimp [d]; linarith
  have hdb : d < b := by dsimp [d]; linarith
  have hper : coverLocalPerimeter A (Metric.closedBall (0 : Cover) d) ≤ ENNReal.ofReal L := by
    rw [hL]
    exact coverLocalPerimeter_mono A (Metric.closedBall_subset_ball hdb)
  have hh := moving_blowup_normal_mass_le_competitor hV hE hmin hμ c r hr hrlim hA hA
    hconv hν ha had (hdb.le.trans hb1) ENNReal.toReal_nonneg hper (by simp)
  have hh' := ENNReal.ofReal_le_ofReal hh
  rw [Measure.real,ENNReal.ofReal_toReal (measure_ne_top (ν : Measure BlowupNormalBundle) _)] at hh'
  exact hh'.trans_eq hL

end CubicTorus

end
end

section

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

lemma blowup_test_inner_bound {F : Cover → Cover} (hn : ∀ x, ‖F x‖ ≤ 1)
    (z : BlowupNormalBundle) : |⟪(z.2 : Cover),F z.1⟫| ≤ 1 := by
  have hh : |⟪(z.2 : Cover),F z.1⟫| ≤ ‖F z.1‖ := by
    simpa only [Real.norm_eq_abs,z.2.property,one_mul] using
      norm_inner_le_norm (𝕜 := ℝ) (z.2 : Cover) (F z.1)
  exact hh.trans (hn _)

theorem blowupNormal_weighted_saturation {A O : Set Cover}
    {ν : FiniteMeasure BlowupNormalBundle}
    (heq : coverLocalPerimeter A O = (ν : Measure BlowupNormalBundle) {z | z.1 ∈ O})
    (hflux : ∀ F : Cover → Cover, ContDiff ℝ (⊤ : ℕ∞) F → HasCompactSupport F →
      tsupport F ⊆ O → (∀ x, ‖F x‖ ≤ 1) →
      (∫ z, ⟪(z.2 : Cover),F z.1⟫ ∂(ν : Measure BlowupNormalBundle)) =
        ∫ x in A, divergence F x)
    {w : BlowupNormalBundle → ℝ}
    (hiw : Integrable w ((ν : Measure BlowupNormalBundle).restrict {z | z.1 ∈ O}))
    {C : ℝ} (hC : 0 < C) (hwC : ∀ z, w z ≤ C)
    {L : ℝ}
    (hL : ∀ F : Cover → Cover, ContDiff ℝ (⊤ : ℕ∞) F → HasCompactSupport F →
      tsupport F ⊆ O → (∀ x, ‖F x‖ ≤ 1) →
      (∫ z in {z : BlowupNormalBundle | z.1 ∈ O}, w z*⟪(z.2 : Cover),F z.1⟫
        ∂(ν : Measure BlowupNormalBundle)) ≤ L) :
    (∫ z in {z : BlowupNormalBundle | z.1 ∈ O}, w z
      ∂(ν : Measure BlowupNormalBundle)) ≤ L := by
  let μ := (ν : Measure BlowupNormalBundle).restrict {z | z.1 ∈ O}
  let P : ℝ := (coverLocalPerimeter A O).toReal
  let I : ℝ := ∫ z, w z ∂μ
  let B : ℝ := P+(L-I)/C
  have hmass : (∫ _ : BlowupNormalBundle, (1 : ℝ) ∂μ) = P := by
    simp only [integral_const,smul_eq_mul,mul_one,μ,P,heq,Measure.real,Measure.restrict_apply_univ]
  have hbound (F : Cover → Cover) (hF : ContDiff ℝ (⊤ : ℕ∞) F)
      (hs : HasCompactSupport F) (hO : tsupport F ⊆ O) (hn : ∀ x, ‖F x‖ ≤ 1) :
      (∫ x in A, divergence F x) ≤ B := by
    let T : BlowupNormalBundle → ℝ := fun z ↦ ⟪(z.2 : Cover),F z.1⟫
    have hTc : Continuous T := (continuous_subtype_val.comp continuous_snd).inner
      (hF.continuous.comp continuous_fst)
    have hTb (z : BlowupNormalBundle) : |T z| ≤ 1 := blowup_test_inner_bound hn z
    have hiT : Integrable T μ := Integrable.of_bound hTc.aestronglyMeasurable 1
      (ae_of_all μ hTb)
    have hiwT : Integrable (fun z ↦ w z*T z) μ := by
      simpa only [mul_comm] using hiw.bdd_mul hTc.aestronglyMeasurable (ae_of_all μ hTb)
    have hh := integral_mono (hiw.sub hiwT)
      (((integrable_const (1 : ℝ)).sub hiT).const_mul C) (fun z ↦ show
        w z-w z*T z ≤ C*(1-T z) from by
          have ht : 0 ≤ 1-T z := by linarith [(le_abs_self (T z)).trans (hTb z)]
          nlinarith [mul_le_mul_of_nonneg_right (hwC z) ht])
    simp only [Pi.sub_apply] at hh
    rw [integral_sub hiw hiwT,integral_const_mul,integral_sub (integrable_const 1) hiT,hmass] at hh
    have hf : (∫ z, T z ∂μ) = ∫ x in A, divergence F x := by
      rw [show (∫ z, T z ∂μ) = ∫ z, T z ∂(ν : Measure BlowupNormalBundle) from ?_]
      · exact hflux F hF hs hO hn
      apply setIntegral_eq_integral_of_forall_compl_eq_zero
      intro z hz
      have hzF : F z.1 = 0 := image_eq_zero_of_notMem_tsupport (fun hh ↦ hz (hO hh))
      simp only [T,hzF,inner_zero_right]
    rw [hf] at hh
    have hl := hL F hF hs hO hn
    change (∫ z, w z*T z ∂μ) ≤ L at hl
    dsimp only [B]
    apply (mul_le_mul_iff_left₀ hC).mp
    rw [add_mul,div_mul_cancel₀ _ hC.ne']
    dsimp only [I]
    nlinarith
  have hB : 0 ≤ B := by
    have hh := hbound (fun _ ↦ 0) contDiff_const HasCompactSupport.zero (by simp) (by simp)
    simpa only [divergence_zero,integral_zero] using hh
  have hper : coverLocalPerimeter A O ≤ ENNReal.ofReal B := by
    apply iSup_le; intro F
    apply iSup_le; intro hF
    apply iSup_le; intro hs
    apply iSup_le; intro hO
    apply iSup_le; intro hn
    exact ENNReal.ofReal_le_ofReal (hbound F hF hs hO hn)
  have hPB : P ≤ B := by
    simpa only [P,ENNReal.toReal_ofReal hB] using ENNReal.toReal_mono ENNReal.ofReal_ne_top hper
  have hnon : 0 ≤ (L-I)/C := by dsimp only [B] at hPB; linarith
  have hh := mul_nonneg hnon hC.le
  rw [div_mul_cancel₀ _ hC.ne'] at hh
  exact sub_nonneg.mp hh

end CubicTorus

end
end

section

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

lemma setIntegral_divergence_congr_local {A B O : Set Cover}
    (hA : MeasurableSet A) (hB : MeasurableSet B)
    (hAB : ∀ᵐ x ∂(volume : Measure Cover), x ∈ O → (x ∈ A ↔ x ∈ B))
    {F : Cover → Cover} (hs : tsupport F ⊆ O) :
    (∫ x in A, divergence F x) = ∫ x in B, divergence F x := by
  rw [← integral_indicator hA,← integral_indicator hB]
  apply integral_congr_ae
  filter_upwards [hAB] with x hx
  by_cases ho : x ∈ O
  · have hh := hx ho
    by_cases ha : x ∈ A
    · simp only [indicator_of_mem ha,indicator_of_mem (hh.mp ha)]
    · simp only [indicator_of_notMem ha,indicator_of_notMem (mt hh.mpr ha)]
  · have hz : divergence F x = 0 := divergence_of_notMem_tsupport (fun hh ↦ ho (hs hh))
    by_cases ha : x ∈ A <;> by_cases hb : x ∈ B <;> simp [ha,hb,hz]

lemma coverLocalPerimeter_congr_local {A B O : Set Cover}
    (hA : MeasurableSet A) (hB : MeasurableSet B)
    (hAB : ∀ᵐ x ∂(volume : Measure Cover), x ∈ O → (x ∈ A ↔ x ∈ B)) :
    coverLocalPerimeter A O = coverLocalPerimeter B O := by
  unfold coverLocalPerimeter
  apply iSup_congr; intro F
  apply iSup_congr; intro _
  apply iSup_congr; intro _
  apply iSup_congr; intro hs
  apply iSup_congr; intro _
  rw [setIntegral_divergence_congr_local hA hB hAB hs]

end CubicTorus

end
end

section

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

def coverHalfspace (n : Cover) : Set Cover := {x | ⟪n,x⟫ < 0}

lemma measurableSet_coverHalfspace (n : Cover) : MeasurableSet (coverHalfspace n) :=
  measurableSet_lt (by fun_prop) measurable_const

lemma halfspace_indicator_eq (n : Cover) :
    (coverHalfspace n).indicator (fun _ ↦ (1 : ℝ)) = halfspaceIndicator n := rfl

lemma setIntegral_coverHalfspace_divergence {n : Cover} (hn : ‖n‖ = 1)
    {F : Cover → Cover} (hF : ContDiff ℝ (⊤ : ℕ∞) F) (hs : HasCompactSupport F) :
    (∫ x in coverHalfspace n, divergence F x) =
      ∫ y : Plane, ⟪n,F (normalPlaneEmbedding n y)⟫ := by
  have hh := integral_halfspace_divergence 0 hn hF hs
  simp only [sub_zero,zero_add] at hh
  rw [← hh,← halfspace_indicator_eq]
  simp only [← indicator_mul_left,one_mul,integral_indicator (measurableSet_coverHalfspace n)]

lemma coverHalfspace_flux_le {n : Cover} (hn : ‖n‖ = 1)
    {F : Cover → Cover} (hF : ContDiff ℝ (⊤ : ℕ∞) F) (hs : HasCompactSupport F)
    {b : ℝ} (hb : 0 ≤ b) (hFb : tsupport F ⊆ Metric.closedBall (0 : Cover) b)
    (hbound : ∀ x, ‖F x‖ ≤ 1) :
    (∫ x in coverHalfspace n, divergence F x) ≤ Real.pi*b^2 := by
  rw [setIntegral_coverHalfspace_divergence hn hF hs]
  have hc : Continuous (fun y : Plane ↦ ⟪n,F (normalPlaneEmbedding n y)⟫) := by
    have hh := (normalColumnChart_plane_isometry 0 hn 0).continuous
    simp only [normalColumnChart_apply 0 hn,zero_smul,add_zero,zero_add] at hh
    exact continuous_const.inner (hF.continuous.comp hh)
  have hsc : HasCompactSupport (fun y : Plane ↦ ⟪n,F (normalPlaneEmbedding n y)⟫) := by
    have hss := hs.comp_isClosedEmbedding (normalColumnChart_plane_isometry 0 hn 0).isClosedEmbedding
    have hh := hss.comp_left (show ⟪n,(0 : Cover)⟫ = 0 by simp)
    simpa only [Function.comp_def,normalColumnChart_apply 0 hn,zero_smul,add_zero,zero_add] using hh
  have hi : Integrable (fun y : Plane ↦ ⟪n,F (normalPlaneEmbedding n y)⟫) := hc.integrable_of_hasCompactSupport hsc
  have hbint : Integrable ((Metric.closedBall (0 : Plane) b).indicator (fun _ ↦ (1 : ℝ))) :=
    (integrableOn_const measure_closedBall_lt_top.ne).integrable_indicator Metric.isClosed_closedBall.measurableSet
  have hh := integral_mono hi hbint (fun y ↦ ?_)
  · have hv : (volume : Measure Plane).real (Metric.closedBall 0 b) = Real.pi*b^2 := by
      simp only [Measure.real,EuclideanSpace.volume_closedBall_fin_two,ENNReal.toReal_mul,
        ENNReal.toReal_pow,ENNReal.toReal_ofReal hb,ENNReal.toReal_ofReal Real.pi_pos.le]
      ring
    rw [integral_indicator Metric.isClosed_closedBall.measurableSet,integral_const,
      smul_eq_mul,mul_one,measureReal_restrict_apply_univ,hv] at hh
    exact hh
  · by_cases hy : y ∈ Metric.closedBall (0 : Plane) b
    · rw [indicator_of_mem hy]
      exact (real_inner_le_norm _ _).trans (by rw [hn,one_mul]; exact hbound _)
    · rw [indicator_of_notMem hy]
      have hz : F (normalPlaneEmbedding n y) = 0 := image_eq_zero_of_notMem_tsupport (fun hh ↦ hy (by
        simpa only [Metric.mem_closedBall,dist_zero_right,normalPlaneEmbedding_norm] using hFb hh))
      simp [hz]

lemma coverLocalPerimeter_halfspace_le {n : Cover} (hn : ‖n‖ = 1) {b : ℝ} (hb : 0 ≤ b) :
    coverLocalPerimeter (coverHalfspace n) (Metric.closedBall (0 : Cover) b) ≤
      ENNReal.ofReal (Real.pi*b^2) := by
  apply iSup_le; intro F
  apply iSup_le; intro hF
  apply iSup_le; intro hs
  apply iSup_le; intro hbF
  apply iSup_le; intro hbound
  exact ENNReal.ofReal_le_ofReal (coverHalfspace_flux_le hn hF hs hb hbF hbound)

theorem coverLocalPerimeter_halfspace {n : Cover} (hn : ‖n‖ = 1) {b : ℝ} (hb : 0 < b) :
    coverLocalPerimeter (coverHalfspace n) (Metric.closedBall (0 : Cover) b) =
      ENNReal.ofReal (Real.pi*b^2) := by
  apply le_antisymm (coverLocalPerimeter_halfspace_le hn hb.le)
  have ht := ENNReal.continuous_ofReal.continuousAt.tendsto.comp
    (integral_radialDensityWeight_plane_tendsto n hb)
  apply le_of_tendsto ht
  filter_upwards [self_mem_nhdsWithin] with ε hε
  let F : Cover → Cover := fun x ↦ radialDensityWeight 0 b ε x • n
  have hF : ContDiff ℝ (⊤ : ℕ∞) F := (radialDensityWeight_contDiff 0 b ε).smul_const n
  have hs : HasCompactSupport F := (radialDensityWeight_hasCompactSupport hb.le hε).smul_right
  have hFb : tsupport F ⊆ Metric.closedBall (0 : Cover) b :=
    (tsupport_smul_subset_left (f := radialDensityWeight 0 b ε) (g := fun _ ↦ n)).trans
      (radialDensityWeight_tsupport hb.le hε)
  have hbound (x : Cover) : ‖F x‖ ≤ 1 := by
    change ‖radialDensityWeight 0 b ε x • n‖ ≤ 1
    rw [norm_smul,hn,mul_one,Real.norm_eq_abs,abs_of_nonneg (radialDensityWeight_nonneg _ _ _ _)]
    exact radialDensityWeight_le_one _ _ _ _
  have he : (∫ x in coverHalfspace n, divergence F x) =
      ∫ y : Plane, radialDensityWeight 0 b ε (normalPlaneEmbedding n y) := by
    rw [setIntegral_coverHalfspace_divergence hn hF hs]
    simp only [F,inner_smul_right,real_inner_self_eq_norm_sq,hn,one_pow,mul_one]
  dsimp only [Function.comp_apply]
  rw [← he]
  exact le_iSup_of_le F (le_iSup_of_le hF (le_iSup_of_le hs
    (le_iSup_of_le hFb (le_iSup_of_le hbound le_rfl))))

end CubicTorus

end
end

section

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

lemma plane_scalar_trace_integrable {n : Cover} (hn : ‖n‖ = 1)
    {φ : Cover → ℝ} (hφ : Continuous φ) (hs : HasCompactSupport φ) :
    Integrable (fun y : Plane ↦ φ (normalPlaneEmbedding n y)) := by
  have he : (fun y : Plane ↦ normalColumnChart 0 n (0,y)) = normalPlaneEmbedding n := by
    funext y
    simp only [normalColumnChart_apply 0 hn,zero_smul,add_zero,zero_add]
  have hi := (normalColumnChart_plane_isometry 0 hn 0)
  have hc : Continuous (normalPlaneEmbedding n) := he ▸ hi.continuous
  have hh : Topology.IsClosedEmbedding (normalPlaneEmbedding n) := he ▸ hi.isClosedEmbedding
  exact (hφ.comp hc).integrable_of_hasCompactSupport (hs.comp_isClosedEmbedding hh)

theorem blowup_flat_patch_weighted_flux {A O U : Set Cover} (hA : MeasurableSet A)
    {n : Cover} (hn : ‖n‖ = 1)
    (hflat : ∀ᵐ x : Cover ∂volume, x ∈ U → (x ∈ A ↔ x ∈ coverHalfspace n))
    {ν : FiniteMeasure BlowupNormalBundle}
    (hflux : ∀ F : Cover → Cover, ContDiff ℝ (⊤ : ℕ∞) F → HasCompactSupport F →
      tsupport F ⊆ O → (∀ x, ‖F x‖ ≤ 1) →
      (∫ z, ⟪(z.2 : Cover),F z.1⟫ ∂(ν : Measure BlowupNormalBundle)) =
        ∫ x in A, divergence F x)
    {φ : Cover → ℝ} (hφ : ContDiff ℝ (⊤ : ℕ∞) φ) (hsφ : HasCompactSupport φ)
    (hφU : tsupport φ ⊆ U) (hφO : tsupport φ ⊆ O) (hφb : ∀ x, φ x ∈ Icc 0 1)
    {F : Cover → Cover} (hF : ContDiff ℝ (⊤ : ℕ∞) F) (hnF : ∀ x, ‖F x‖ ≤ 1) :
    (∫ z in {z : BlowupNormalBundle | z.1 ∈ O}, φ z.1*⟪(z.2 : Cover),F z.1⟫
      ∂(ν : Measure BlowupNormalBundle)) =
      ∫ y : Plane, φ (normalPlaneEmbedding n y)*⟪n,F (normalPlaneEmbedding n y)⟫ := by
  let H : Cover → Cover := fun x ↦ φ x • F x
  have hH : ContDiff ℝ (⊤ : ℕ∞) H := hφ.smul hF
  have hsH : HasCompactSupport H := hsφ.smul_right
  have hHU : tsupport H ⊆ U := (tsupport_smul_subset_left _ _).trans hφU
  have hHO : tsupport H ⊆ O := (tsupport_smul_subset_left _ _).trans hφO
  have hnH (x) : ‖H x‖ ≤ 1 := by
    rw [norm_smul,Real.norm_eq_abs,abs_of_nonneg (hφb x).1]
    exact (mul_le_mul (hφb x).2 (hnF x) (norm_nonneg _) zero_le_one).trans_eq (one_mul 1)
  have he : (∫ z in {z : BlowupNormalBundle | z.1 ∈ O}, ⟪(z.2 : Cover),H z.1⟫
      ∂(ν : Measure BlowupNormalBundle)) = ∫ z, ⟪(z.2 : Cover),H z.1⟫ ∂(ν : Measure BlowupNormalBundle) := by
    apply setIntegral_eq_integral_of_forall_compl_eq_zero
    intro z hz
    have hh : H z.1 = 0 := image_eq_zero_of_notMem_tsupport (fun h ↦ hz (hHO h))
    simp only [hh,inner_zero_right]
  have hh := hflux H hH hsH hHO hnH
  rw [setIntegral_divergence_congr_local hA (measurableSet_coverHalfspace n) hflat hHU,
    setIntegral_coverHalfspace_divergence hn hH hsH] at hh
  rw [← he] at hh
  simpa only [H,inner_smul_right] using hh

theorem blowup_flat_patch_weighted_mass {A O U : Set Cover} (hA : MeasurableSet A)
    {n : Cover} (hn : ‖n‖ = 1)
    (hflat : ∀ᵐ x : Cover ∂volume, x ∈ U → (x ∈ A ↔ x ∈ coverHalfspace n))
    {ν : FiniteMeasure BlowupNormalBundle}
    (heq : coverLocalPerimeter A O = (ν : Measure BlowupNormalBundle) {z | z.1 ∈ O})
    (hflux : ∀ F : Cover → Cover, ContDiff ℝ (⊤ : ℕ∞) F → HasCompactSupport F →
      tsupport F ⊆ O → (∀ x, ‖F x‖ ≤ 1) →
      (∫ z, ⟪(z.2 : Cover),F z.1⟫ ∂(ν : Measure BlowupNormalBundle)) =
        ∫ x in A, divergence F x)
    {φ : Cover → ℝ} (hφ : ContDiff ℝ (⊤ : ℕ∞) φ) (hsφ : HasCompactSupport φ)
    (hφU : tsupport φ ⊆ U) (hφO : tsupport φ ⊆ O) (hφb : ∀ x, φ x ∈ Icc 0 1) :
    (∫ z in {z : BlowupNormalBundle | z.1 ∈ O}, φ z.1 ∂(ν : Measure BlowupNormalBundle)) =
      ∫ y : Plane, φ (normalPlaneEmbedding n y) := by
  let μ := (ν : Measure BlowupNormalBundle).restrict {z | z.1 ∈ O}
  have hiφ : Integrable (fun z : BlowupNormalBundle ↦ φ z.1) μ :=
    Integrable.of_bound (hφ.continuous.comp continuous_fst).aestronglyMeasurable 1
      (ae_of_all μ fun z ↦ by rw [Real.norm_eq_abs,abs_of_nonneg (hφb z.1).1]; exact (hφb z.1).2)
  have hiplane := plane_scalar_trace_integrable hn hφ.continuous hsφ
  have hfield (F : Cover → Cover) (hF : ContDiff ℝ (⊤ : ℕ∞) F) (hnF : ∀ x, ‖F x‖ ≤ 1) :
      (∫ z, φ z.1*⟪(z.2 : Cover),F z.1⟫ ∂μ) ≤ ∫ y : Plane, φ (normalPlaneEmbedding n y) := by
    rw [show (∫ z, φ z.1*⟪(z.2 : Cover),F z.1⟫ ∂μ) = _ from
      blowup_flat_patch_weighted_flux hA hn hflat hflux hφ hsφ hφU hφO hφb hF hnF]
    have hc : Continuous (fun y : Plane ↦ ⟪n,F (normalPlaneEmbedding n y)⟫) := by
      have hh := (normalColumnChart_plane_isometry 0 hn 0).continuous
      simp only [normalColumnChart_apply 0 hn,zero_smul,add_zero,zero_add] at hh
      exact continuous_const.inner (hF.continuous.comp hh)
    have hb (y : Plane) : |⟪n,F (normalPlaneEmbedding n y)⟫| ≤ 1 :=
      by
      have hh : |⟪n,F (normalPlaneEmbedding n y)⟫| ≤ ‖n‖*‖F (normalPlaneEmbedding n y)‖ := by
        simpa only [Real.norm_eq_abs] using norm_inner_le_norm (𝕜 := ℝ) n (F (normalPlaneEmbedding n y))
      exact hh.trans (by rw [hn,one_mul]; exact hnF _)
    have hi := hiplane.bdd_mul hc.aestronglyMeasurable (ae_of_all volume hb)
    apply integral_mono (by simpa only [mul_comm] using hi) hiplane
    intro y
    exact mul_le_of_le_one_right (hφb _).1 ((le_abs_self _).trans (hb y))
  refine le_antisymm ?_ ?_
  · exact blowupNormal_weighted_saturation heq hflux hiφ (by norm_num : (0 : ℝ)<1)
      (fun z ↦ (hφb z.1).2) (fun F hF _ _ hnF ↦ hfield F hF hnF)
  · have he := blowup_flat_patch_weighted_flux hA hn hflat hflux hφ hsφ hφU hφO hφb
      (F := fun _ ↦ n) contDiff_const (fun _ ↦ hn.le)
    simp only [real_inner_self_eq_norm_sq,hn,one_pow,mul_one] at he
    rw [← he]
    have hiinner : Integrable (fun z : BlowupNormalBundle ↦ φ z.1*⟪(z.2 : Cover),n⟫) μ := by
      simpa only [mul_comm] using hiφ.bdd_mul
        (show Continuous (fun z : BlowupNormalBundle ↦ ⟪(z.2 : Cover),n⟫) from by fun_prop).aestronglyMeasurable
        (ae_of_all μ fun z ↦ blowup_test_inner_bound (F := fun _ ↦ n) (fun _ ↦ hn.le) z)
    apply integral_mono hiinner hiφ
    intro z
    apply mul_le_of_le_one_right (hφb _).1
    exact (real_inner_le_norm (z.2 : Cover) n).trans_eq (by rw [z.2.property,hn,one_mul])

theorem blowup_flat_patch_normal {A O U : Set Cover} (hA : MeasurableSet A)
    {n : Cover} (hn : ‖n‖ = 1)
    (hflat : ∀ᵐ x : Cover ∂volume, x ∈ U → (x ∈ A ↔ x ∈ coverHalfspace n))
    {ν : FiniteMeasure BlowupNormalBundle}
    (heq : coverLocalPerimeter A O = (ν : Measure BlowupNormalBundle) {z | z.1 ∈ O})
    (hflux : ∀ F : Cover → Cover, ContDiff ℝ (⊤ : ℕ∞) F → HasCompactSupport F →
      tsupport F ⊆ O → (∀ x, ‖F x‖ ≤ 1) →
      (∫ z, ⟪(z.2 : Cover),F z.1⟫ ∂(ν : Measure BlowupNormalBundle)) =
        ∫ x in A, divergence F x)
    {φ : Cover → ℝ} (hφ : ContDiff ℝ (⊤ : ℕ∞) φ) (hsφ : HasCompactSupport φ)
    (hφU : tsupport φ ⊆ U) (hφO : tsupport φ ⊆ O) (hφb : ∀ x, φ x ∈ Icc 0 1) :
    ∀ᵐ z ∂(ν : Measure BlowupNormalBundle).restrict {z | z.1 ∈ O},
      0 < φ z.1 → (z.2 : Cover) = n := by
  let μ := (ν : Measure BlowupNormalBundle).restrict {z | z.1 ∈ O}
  have hiφ : Integrable (fun z : BlowupNormalBundle ↦ φ z.1) μ :=
    Integrable.of_bound (hφ.continuous.comp continuous_fst).aestronglyMeasurable 1
      (ae_of_all μ fun z ↦ by rw [Real.norm_eq_abs,abs_of_nonneg (hφb z.1).1]; exact (hφb z.1).2)
  have hiinner : Integrable (fun z : BlowupNormalBundle ↦ φ z.1*⟪(z.2 : Cover),n⟫) μ := by
    simpa only [mul_comm] using hiφ.bdd_mul
      (show Continuous (fun z : BlowupNormalBundle ↦ ⟪(z.2 : Cover),n⟫) from by fun_prop).aestronglyMeasurable
      (ae_of_all μ fun z ↦ blowup_test_inner_bound (F := fun _ ↦ n) (fun _ ↦ hn.le) z)
  have hm := blowup_flat_patch_weighted_mass hA hn hflat heq hflux hφ hsφ hφU hφO hφb
  have hf := blowup_flat_patch_weighted_flux hA hn hflat hflux hφ hsφ hφU hφO hφb
    (F := fun _ ↦ n) contDiff_const (fun _ ↦ hn.le)
  simp only [real_inner_self_eq_norm_sq,hn,one_pow,mul_one] at hf
  have hz : (∫ z, (φ z.1-φ z.1*⟪(z.2 : Cover),n⟫) ∂μ) = 0 := by
    rw [integral_sub hiφ hiinner,hm,hf,sub_self]
  have hnon (z : BlowupNormalBundle) : 0 ≤ φ z.1-φ z.1*⟪(z.2 : Cover),n⟫ := by
    have hh := (real_inner_le_norm (z.2 : Cover) n)
    rw [z.2.property,hn,one_mul] at hh
    nlinarith [(hφb z.1).1,mul_nonneg (hφb z.1).1 (sub_nonneg.mpr hh)]
  have hae := (integral_eq_zero_iff_of_nonneg_ae (ae_of_all μ hnon) (hiφ.sub hiinner)).mp hz
  filter_upwards [hae] with z hz hp
  change φ z.1-φ z.1*⟪(z.2 : Cover),n⟫ = 0 at hz
  have hh : ⟪(z.2 : Cover),n⟫ = 1 := by nlinarith
  apply sub_eq_zero.mp
  apply norm_eq_zero.mp
  have hs : ‖(z.2 : Cover)-n‖^2 = 0 := by rw [norm_sub_sq_real,z.2.property,hn,hh]; norm_num
  exact sq_eq_zero_iff.mp hs

end CubicTorus

end
end

end

end OAI