import Mathlib
import OAI.Geometry.CubicTorus.Compactness.BVWeyl

namespace OAI

section

section

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

def coordinateTriangle (b l u : ℝ) : Set (ℝ × ℝ) :=
  {z | z.2 ∈ Ioc 0 b ∧ z.1 ∈ Ioc (z.2*l) (z.2*u)}

lemma measurableSet_coordinateTriangle (b l u : ℝ) : MeasurableSet (coordinateTriangle b l u) := by
  exact (measurable_snd measurableSet_Ioc).inter
    ((measurableSet_lt (measurable_snd.mul_const l) measurable_fst).inter
      (measurableSet_le measurable_fst (measurable_snd.mul_const u)))

lemma integralOn_coordinateTriangle {f : ℝ × ℝ → ℝ} {b l u : ℝ}
    (hf : IntegrableOn f (coordinateTriangle b l u)) (hb : 0 ≤ b) (hlu : l ≤ u) :
    (∫ z in coordinateTriangle b l u, f z) =
      ∫ s in (0 : ℝ)..b, ∫ x in (s*l)..(s*u), f (x,s) := by
  rw [← integral_indicator (measurableSet_coordinateTriangle b l u),Measure.volume_eq_prod]
  have hi := hf.integrable_indicator (measurableSet_coordinateTriangle b l u)
  rw [Measure.volume_eq_prod] at hi
  rw [integral_prod_symm _ hi]
  have he (s : ℝ) : (∫ x : ℝ, (coordinateTriangle b l u).indicator f (x,s)) =
      (Ioc (0 : ℝ) b).indicator (fun s ↦ ∫ x in (s*l)..(s*u), f (x,s)) s := by
    by_cases hs : s ∈ Ioc (0 : ℝ) b
    · rw [indicator_of_mem hs,intervalIntegral.integral_of_le (mul_le_mul_of_nonneg_left hlu hs.1.le)]
      rw [← integral_indicator measurableSet_Ioc]
      apply integral_congr_ae
      apply ae_of_all
      intro x
      change (coordinateTriangle b l u).indicator f (x,s) =
        (Ioc (s*l) (s*u)).indicator (fun x ↦ f (x,s)) x
      by_cases hx : x ∈ Ioc (s*l) (s*u)
      · erw [indicator_of_mem (show (x,s) ∈ coordinateTriangle b l u from ⟨hs,hx⟩),indicator_of_mem hx]
      · erw [indicator_of_notMem (show (x,s) ∉ coordinateTriangle b l u from fun h ↦ hx h.2),indicator_of_notMem hx]
    · rw [indicator_of_notMem hs]
      apply integral_eq_zero_of_ae
      exact ae_of_all _ (fun x ↦ indicator_of_notMem
        (show (x,s) ∉ coordinateTriangle b l u from fun h ↦ hs h.1) _)
  simp_rw [he]
  rw [integral_indicator measurableSet_Ioc,intervalIntegral.integral_of_le hb]

lemma integral_coordinateTriangle {f : ℝ × ℝ → ℝ} (hf : Integrable f)
    {b l u : ℝ} (hb : 0 ≤ b) (hlu : l ≤ u) :
    (∫ z in coordinateTriangle b l u, f z) =
      ∫ s in (0 : ℝ)..b, ∫ x in (s*l)..(s*u), f (x,s) :=
  integralOn_coordinateTriangle hf.integrableOn hb hlu

theorem integral_coordinateTriangle_divergence {X Y : ℝ × ℝ → ℝ}
    (hX : ContDiff ℝ (⊤ : ℕ∞) X) (hY : ContDiff ℝ (⊤ : ℕ∞) Y)
    (hsX : HasCompactSupport X) (hsY : HasCompactSupport Y)
    {b l u : ℝ} (hb : 0 ≤ b) (hlu : l ≤ u) :
    (∫ z in coordinateTriangle b l u, planarCoordinateDivergence X Y z) =
      (∫ s in (0 : ℝ)..b, (X (s*u,s)-u*Y (s*u,s))-(X (s*l,s)-l*Y (s*l,s))) +
      (∫ x in (b*l)..(b*u), Y (x,b)) := by
  have hiX : Integrable (fun z : ℝ × ℝ ↦ fderiv ℝ X z (1,0)) :=
    ((hX.continuous_fderiv (by simp)).clm_apply continuous_const).integrable_of_hasCompactSupport
      (hsX.fderiv_apply ℝ (1,0))
  have hiY : Integrable (fun z : ℝ × ℝ ↦ fderiv ℝ Y z (0,1)) :=
    ((hY.continuous_fderiv (by simp)).clm_apply continuous_const).integrable_of_hasCompactSupport
      (hsY.fderiv_apply ℝ (0,1))
  have hi : Integrable (planarCoordinateDivergence X Y) := hiX.add hiY
  rw [integral_coordinateTriangle hi hb hlu]
  exact triangle_coordinate_divergence hX hY hb hlu

end CubicTorus

end
end

section

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

abbrev PrismCoordinates := ℝ × (ℝ × ℝ)

def prismCoordinateDivergence (T X Y : PrismCoordinates → ℝ) (z : PrismCoordinates) : ℝ :=
  fderiv ℝ T z (1,(0,0)) + fderiv ℝ X z (0,(1,0)) + fderiv ℝ Y z (0,(0,1))

def coordinatePrism (a c b l u : ℝ) : Set PrismCoordinates :=
  Ioc a c ×ˢ coordinateTriangle b l u

lemma hasDerivAt_prism_axial {T : PrismCoordinates → ℝ}
    (hT : Differentiable ℝ T) (t : ℝ) (z : ℝ × ℝ) :
    HasDerivAt (fun v : ℝ ↦ T (v,z)) (fderiv ℝ T (t,z) (1,(0,0))) t := by
  have h : HasDerivAt (fun v : ℝ ↦ (v,z)) (1,(0,0)) t := by
    convert (hasDerivAt_id t).prodMk (hasDerivAt_const t z) using 1; rfl
  exact (hT (t,z)).hasFDerivAt.comp_hasDerivAt t h

lemma prism_planar_coordinate_derivatives {X Y : PrismCoordinates → ℝ}
    (hX : Differentiable ℝ X) (hY : Differentiable ℝ Y) (t : ℝ) (z : ℝ × ℝ) :
    planarCoordinateDivergence (fun w ↦ X (t,w)) (fun w ↦ Y (t,w)) z =
      fderiv ℝ X (t,z) (0,(1,0)) + fderiv ℝ Y (t,z) (0,(0,1)) := by
  have h : HasFDerivAt (fun w : ℝ × ℝ ↦ (t,w))
      (ContinuousLinearMap.prod (0 : (ℝ × ℝ) →L[ℝ] ℝ) (ContinuousLinearMap.id ℝ (ℝ × ℝ))) z := by
    exact (hasFDerivAt_const t z).prodMk (hasFDerivAt_id z)
  erw [planarCoordinateDivergence,((hX (t,z)).hasFDerivAt.comp z h).fderiv,
    ((hY (t,z)).hasFDerivAt.comp z h).fderiv]
  rfl

lemma compact_support_prism_slice {X : PrismCoordinates → ℝ}
    (hsX : HasCompactSupport X) (t : ℝ) : HasCompactSupport (fun z : ℝ × ℝ ↦ X (t,z)) := by
  apply hsX.comp_isClosedEmbedding
  have hi : Isometry (fun z : ℝ × ℝ ↦ (t,z)) := by
    rw [isometry_iff_dist_eq]
    intro x y
    simp
  exact hi.isClosedEmbedding

theorem integral_coordinatePrism_divergence {T X Y : PrismCoordinates → ℝ}
    (hT : ContDiff ℝ (⊤ : ℕ∞) T) (hX : ContDiff ℝ (⊤ : ℕ∞) X)
    (hY : ContDiff ℝ (⊤ : ℕ∞) Y)
    (hsT : HasCompactSupport T) (hsX : HasCompactSupport X) (hsY : HasCompactSupport Y)
    {a c b l u : ℝ} (hac : a ≤ c) (hb : 0 ≤ b) (hlu : l ≤ u) :
    (∫ z in coordinatePrism a c b l u, prismCoordinateDivergence T X Y z) =
      (∫ z in coordinateTriangle b l u, T (c,z)-T (a,z)) +
      (∫ t in a..c, (∫ s in (0 : ℝ)..b,
        (X (t,(s*u,s))-u*Y (t,(s*u,s)))-(X (t,(s*l,s))-l*Y (t,(s*l,s)))) +
        (∫ x in (b*l)..(b*u), Y (t,(x,b)))) := by
  let DT : PrismCoordinates → ℝ := fun z ↦ fderiv ℝ T z (1,(0,0))
  let DP : PrismCoordinates → ℝ := fun z ↦ fderiv ℝ X z (0,(1,0)) + fderiv ℝ Y z (0,(0,1))
  have iT : Integrable DT :=
    ((hT.continuous_fderiv (by simp)).clm_apply continuous_const).integrable_of_hasCompactSupport
      (hsT.fderiv_apply ℝ (1,(0,0)))
  have iX : Integrable (fun z ↦ fderiv ℝ X z (0,(1,0))) :=
    ((hX.continuous_fderiv (by simp)).clm_apply continuous_const).integrable_of_hasCompactSupport
      (hsX.fderiv_apply ℝ (0,(1,0)))
  have iY : Integrable (fun z ↦ fderiv ℝ Y z (0,(0,1))) :=
    ((hY.continuous_fderiv (by simp)).clm_apply continuous_const).integrable_of_hasCompactSupport
      (hsY.fderiv_apply ℝ (0,(0,1)))
  have iP : Integrable DP := iX.add iY
  have hid : prismCoordinateDivergence T X Y = fun z ↦ DT z + DP z := by
    funext z; dsimp [prismCoordinateDivergence,DT,DP]; ring
  rw [hid,integral_add iT.integrableOn iP.integrableOn]
  congr 1
  · have hi : IntegrableOn DT ((Ioc a c) ×ˢ coordinateTriangle b l u) (volume.prod volume) := by
      rw [← Measure.volume_eq_prod]
      exact iT.integrableOn
    change (∫ z in (Ioc a c) ×ˢ coordinateTriangle b l u, DT z) = _
    rw [Measure.volume_eq_prod,setIntegral_prod DT hi]
    have hi' : Integrable DT ((volume.restrict (Ioc a c)).prod (volume.restrict (coordinateTriangle b l u))) := by
      rwa [Measure.prod_restrict]
    rw [integral_integral_swap hi']
    apply integral_congr_ae
    apply ae_of_all
    intro z
    change (∫ t in Ioc a c, DT (t,z)) = T (c,z)-T (a,z)
    rw [← intervalIntegral.integral_of_le hac]
    exact intervalIntegral.integral_eq_sub_of_hasDerivAt
      (fun t _ ↦ hasDerivAt_prism_axial (hT.differentiable (by simp)) t z)
      (((hT.continuous_fderiv (by simp)).clm_apply continuous_const).comp
        (continuous_id.prodMk continuous_const) |>.intervalIntegrable _ _)
  · have hi : IntegrableOn DP ((Ioc a c) ×ˢ coordinateTriangle b l u) (volume.prod volume) := by
      rw [← Measure.volume_eq_prod]
      exact iP.integrableOn
    change (∫ z in (Ioc a c) ×ˢ coordinateTriangle b l u, DP z) = _
    rw [Measure.volume_eq_prod,setIntegral_prod DP hi,← intervalIntegral.integral_of_le hac]
    apply intervalIntegral.integral_congr
    intro t _
    have hsX' := compact_support_prism_slice hsX t
    have hsY' := compact_support_prism_slice hsY t
    have hX' : ContDiff ℝ (⊤ : ℕ∞) (fun z : ℝ × ℝ ↦ X (t,z)) := by fun_prop
    have hY' : ContDiff ℝ (⊤ : ℕ∞) (fun z : ℝ × ℝ ↦ Y (t,z)) := by fun_prop
    have he (z : ℝ × ℝ) : DP (t,z) =
        planarCoordinateDivergence (fun w ↦ X (t,w)) (fun w ↦ Y (t,w)) z :=
      (prism_planar_coordinate_derivatives (hX.differentiable (by simp))
        (hY.differentiable (by simp)) t z).symm
    simp_rw [he]
    exact integral_coordinateTriangle_divergence hX' hY' hsX' hsY' hb hlu

end CubicTorus

end
end

section

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

lemma coordinateTriangle_subset_box {b l u : ℝ} (_hb : 0 ≤ b) :
    coordinateTriangle b l u ⊆
      Icc (-b*max |l| |u|) (b*max |l| |u|) ×ˢ Icc 0 b := by
  intro z hz
  have hs0 : 0 ≤ z.2 := hz.1.1.le
  have hs : z.2 ≤ b := hz.1.2
  have hm : 0 ≤ max |l| |u| := le_trans (abs_nonneg l) (le_max_left _ _)
  have hlo : -max |l| |u| ≤ l := by linarith [neg_abs_le l,le_max_left |l| |u|]
  have hup : u ≤ max |l| |u| := le_trans (le_abs_self u) (le_max_right _ _)
  have hh := mul_le_mul_of_nonneg_right hs hm
  have hl := mul_le_mul_of_nonneg_left hlo hs0
  have hu := mul_le_mul_of_nonneg_left hup hs0
  exact ⟨⟨by nlinarith [hz.2.1],by nlinarith [hz.2.2]⟩,hs0,hs⟩

lemma coordinateTriangle_measure_lt_top {b l u : ℝ} (hb : 0 ≤ b) :
    volume (coordinateTriangle b l u) < ⊤ :=
  (measure_mono (coordinateTriangle_subset_box hb)).trans_lt
    (isCompact_Icc.prod isCompact_Icc).measure_lt_top

theorem volume_real_coordinateTriangle {b l u : ℝ} (hb : 0 ≤ b) (hlu : l ≤ u) :
    volume.real (coordinateTriangle b l u) = b^2*(u-l)/2 := by
  have hi : IntegrableOn (fun _ : ℝ × ℝ ↦ (1 : ℝ)) (coordinateTriangle b l u) :=
    integrableOn_const (coordinateTriangle_measure_lt_top hb).ne
  have he := integralOn_coordinateTriangle hi hb hlu
  simp only [integral_const,smul_eq_mul,mul_one,measureReal_restrict_apply_univ,
    intervalIntegral.integral_const] at he
  have hf : (fun s : ℝ ↦ s*u-s*l) = fun s ↦ (u-l)*s := by funext s; ring
  rw [hf,intervalIntegral.integral_const_mul,integral_id] at he
  convert he using 1; ring

lemma abs_planar_normal_flux {x y : ℝ} (h : x^2+y^2 ≤ 1) (k : ℝ) :
    |x-k*y| ≤ Real.sqrt (1+k^2) := by
  have hk : 0 ≤ 1+k^2 := by positivity
  have hs := Real.sq_sqrt hk
  have h0 := Real.sqrt_nonneg (1+k^2)
  have he := mul_nonneg hk (show 0 ≤ 1-x^2-y^2 by linarith)
  have hsq : (x-k*y)^2 ≤ 1+k^2 := by nlinarith [sq_nonneg (k*x+y)]
  nlinarith [sq_abs (x-k*y),abs_nonneg (x-k*y)]

lemma abs_planar_second_flux {x y : ℝ} (h : x^2+y^2 ≤ 1) : |y| ≤ 1 := by
  nlinarith [sq_nonneg x,sq_abs y,abs_nonneg y]

theorem abs_integral_coordinateTriangle_divergence_le {X Y : ℝ × ℝ → ℝ}
    (hX : ContDiff ℝ (⊤ : ℕ∞) X) (hY : ContDiff ℝ (⊤ : ℕ∞) Y)
    (hsX : HasCompactSupport X) (hsY : HasCompactSupport Y)
    (hn : ∀ z, (X z)^2+(Y z)^2 ≤ 1)
    {b l u : ℝ} (hb : 0 ≤ b) (hlu : l ≤ u) :
    |∫ z in coordinateTriangle b l u, planarCoordinateDivergence X Y z| ≤
      b*(Real.sqrt (1+l^2)+Real.sqrt (1+u^2)+(u-l)) := by
  rw [integral_coordinateTriangle_divergence hX hY hsX hsY hb hlu]
  have hface (s : ℝ) :
      |(X (s*u,s)-u*Y (s*u,s))-(X (s*l,s)-l*Y (s*l,s))| ≤
        Real.sqrt (1+l^2)+Real.sqrt (1+u^2) := by
    have hu := abs_planar_normal_flux (hn (s*u,s)) u
    have hl := abs_planar_normal_flux (hn (s*l,s)) l
    exact (abs_sub _ _).trans (by linarith)
  have hfaceint := intervalIntegral.norm_integral_le_of_norm_le_const
    (a := (0 : ℝ)) (b := b) (fun s _ ↦ show
      ‖(X (s*u,s)-u*Y (s*u,s))-(X (s*l,s)-l*Y (s*l,s))‖ ≤
        Real.sqrt (1+l^2)+Real.sqrt (1+u^2) by simpa only [Real.norm_eq_abs] using hface s)
  have hcapint := intervalIntegral.norm_integral_le_of_norm_le_const
    (a := b*l) (b := b*u) (fun x _ ↦ show ‖Y (x,b)‖ ≤ (1 : ℝ) by
      simpa only [Real.norm_eq_abs] using abs_planar_second_flux (hn (x,b)))
  have hbl : b*l ≤ b*u := mul_le_mul_of_nonneg_left hlu hb
  simp only [Real.norm_eq_abs,sub_zero,abs_of_nonneg hb,one_mul,
    abs_of_nonneg (sub_nonneg.mpr hbl)] at hfaceint hcapint
  exact (abs_add_le _ _).trans (by nlinarith)

theorem triangular_chord_margin_pos (l u : ℝ) :
    0 < Real.sqrt (1+l^2)+Real.sqrt (1+u^2)-(u-l) := by
  have hl : |l| < Real.sqrt (1+l^2) := by
    have hs := Real.sq_sqrt (show 0 ≤ 1+l^2 by positivity)
    nlinarith [sq_abs l,abs_nonneg l,Real.sqrt_nonneg (1+l^2)]
  have hu : |u| < Real.sqrt (1+u^2) := by
    have hs := Real.sq_sqrt (show 0 ≤ 1+u^2 by positivity)
    nlinarith [sq_abs u,abs_nonneg u,Real.sqrt_nonneg (1+u^2)]
  linarith [neg_abs_le l,le_abs_self u]

end CubicTorus

end
end

section

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

def prismRadialFlux (X Y : PrismCoordinates → ℝ) (a c b l u : ℝ) : ℝ :=
  ∫ t in a..c, ∫ s in (0 : ℝ)..b,
    (X (t,(s*u,s))-u*Y (t,(s*u,s)))-(X (t,(s*l,s))-l*Y (t,(s*l,s)))

def prismClosingFlux (T Y : PrismCoordinates → ℝ) (a c b l u : ℝ) : ℝ :=
  (∫ z in coordinateTriangle b l u, T (c,z)-T (a,z)) +
    (∫ t in a..c, ∫ x in (b*l)..(b*u), Y (t,(x,b)))

lemma integral_coordinatePrism_divergence_split {T X Y : PrismCoordinates → ℝ}
    (hT : ContDiff ℝ (⊤ : ℕ∞) T) (hX : ContDiff ℝ (⊤ : ℕ∞) X)
    (hY : ContDiff ℝ (⊤ : ℕ∞) Y)
    (hsT : HasCompactSupport T) (hsX : HasCompactSupport X) (hsY : HasCompactSupport Y)
    {a c b l u : ℝ} (hac : a ≤ c) (hb : 0 ≤ b) (hlu : l ≤ u) :
    (∫ z in coordinatePrism a c b l u, prismCoordinateDivergence T X Y z) =
      prismRadialFlux X Y a c b l u + prismClosingFlux T Y a c b l u := by
  rw [integral_coordinatePrism_divergence hT hX hY hsT hsX hsY hac hb hlu]
  have hr : Continuous (fun t : ℝ ↦ ∫ s in (0 : ℝ)..b,
      (X (t,(s*u,s))-u*Y (t,(s*u,s)))-(X (t,(s*l,s))-l*Y (t,(s*l,s)))) :=
    intervalIntegral.continuous_parametric_intervalIntegral_of_continuous' (by fun_prop) _ _
  have hc : Continuous (fun t : ℝ ↦ ∫ x in (b*l)..(b*u), Y (t,(x,b))) :=
    intervalIntegral.continuous_parametric_intervalIntegral_of_continuous' (by fun_prop) _ _
  rw [intervalIntegral.integral_add (hr.intervalIntegrable _ _) (hc.intervalIntegrable _ _)]
  dsimp [prismRadialFlux,prismClosingFlux]
  ring

theorem abs_prismClosingFlux_le {T Y : PrismCoordinates → ℝ}
    (hT : ∀ z, |T z| ≤ 1) (hY : ∀ z, |Y z| ≤ 1)
    {a c b l u : ℝ} (hac : a ≤ c) (hb : 0 ≤ b) (hlu : l ≤ u) :
    |prismClosingFlux T Y a c b l u| ≤
      (c-a)*b*(u-l)+b^2*(u-l) := by
  have hcap := norm_setIntegral_le_of_norm_le_const
    (coordinateTriangle_measure_lt_top (l := l) (u := u) hb)
    (f := fun z : ℝ × ℝ ↦ T (c,z)-T (a,z)) (C := (2 : ℝ)) (fun z _ ↦ ?_)
  · have hchord (t : ℝ) : |∫ x in (b*l)..(b*u), Y (t,(x,b))| ≤ b*(u-l) := by
      have hi := intervalIntegral.norm_integral_le_of_norm_le_const
        (a := b*l) (b := b*u) (fun x _ ↦ show ‖Y (t,(x,b))‖ ≤ (1 : ℝ) by
          simpa only [Real.norm_eq_abs] using hY (t,(x,b)))
      simp only [Real.norm_eq_abs,one_mul,
        abs_of_nonneg (sub_nonneg.mpr (mul_le_mul_of_nonneg_left hlu hb))] at hi
      nlinarith
    have hi := intervalIntegral.norm_integral_le_of_norm_le_const
      (a := a) (b := c) (fun t _ ↦ show ‖∫ x in (b*l)..(b*u), Y (t,(x,b))‖ ≤ b*(u-l) by
        simpa only [Real.norm_eq_abs] using hchord t)
    rw [volume_real_coordinateTriangle hb hlu,Real.norm_eq_abs] at hcap
    simp only [Real.norm_eq_abs,abs_of_nonneg (sub_nonneg.mpr hac)] at hi
    dsimp [prismClosingFlux]
    exact (abs_add_le _ _).trans (by nlinarith)
  · rw [Real.norm_eq_abs]
    exact (abs_sub _ _).trans (by linarith [hT (c,z),hT (a,z)])

theorem exists_strict_prism_replacement_scale {a c l u : ℝ}
    (hac : a < c) (hlu : l < u) {ε : ℝ} (hε : 0 < ε) :
    ∃ b : ℝ, 0 < b ∧ b < ε ∧
      (c-a)*b*(u-l)+b^2*(u-l) <
        (c-a)*b*(Real.sqrt (1+l^2)+Real.sqrt (1+u^2)) := by
  let m := Real.sqrt (1+l^2)+Real.sqrt (1+u^2)-(u-l)
  have hm : 0 < m := triangular_chord_margin_pos l u
  let b := min (ε/2) ((c-a)*m/(2*(u-l)))
  have hb : 0 < b := lt_min (by positivity) (by positivity)
  have hbe : b < ε := (min_le_left _ _).trans_lt (by linarith)
  have hbs : b*(u-l) ≤ (c-a)*m/2 := by
    have hh := min_le_right (ε/2) ((c-a)*m/(2*(u-l)))
    have hd : 0 < 2*(u-l) := by linarith
    have hh' := (le_div_iff₀ hd).mp hh
    dsimp only [b] at *
    nlinarith
  refine ⟨b,hb,hbe,?_⟩
  have hcm : 0 < (c-a)*m := mul_pos (sub_pos.mpr hac) hm
  have hstrict : b*(u-l) < (c-a)*m := by linarith
  have hmul := mul_lt_mul_of_pos_left hstrict hb
  dsimp only [m] at hmul
  nlinarith

end CubicTorus

end
end

section

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

lemma small_oscillation_boundary_flat {E B : Set Torus} (hE : MeasurableSet E)
    {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) {N : Torus → Cover} (hN : Measurable N)
    (hpolar : ∀ᵐ z ∂(μ : Measure NormalBundle), N (quotientMap z.1) = (z.2 : Cover))
    (hn : ∀ᵐ x ∂(spatialNormalMeasure μ : Measure Torus), ‖N x‖ = 1)
    {R δ : ℝ} (hδ : 0 < δ)
    (hd : ∀ a ∈ B, ∀ t : ℝ, 0 < t → t ≤ R →
      δ * t ^ 3 ≤ torusVolume.real (E ∩ Metric.ball a t) ∧
      δ * t ^ 3 ≤ torusVolume.real (Eᶜ ∩ Metric.ball a t))
    {c : Torus} (hc : c ∈ B) {n : Cover} (hnorm : ‖n‖ = 1)
    {r ε : ℝ} (hr : 0 < r) (hrR : r ≤ R) (hr16 : r ≤ 1/16)
    (hε : 0 < ε) (hε1 : ε ≤ 1)
    (hosc : 131072 * normalOscillation (spatialNormalMeasure μ) N c n (8*r) < δ^2*(ε/4)^6) :
    ∀ y ∈ B, dist y c < r → |⟪n,shortestLift (y-c)⟫| < ε*r := by
  let t := ε * r / 4
  have ht : 0 < t := by dsimp [t]; positivity
  have htr : t ≤ r := by dsimp [t]; nlinarith
  have htR : t ≤ R := htr.trans hrR
  have hquot : t / r = ε / 4 := by dsimp [t]; field_simp
  have hforbid : ∀ a ∈ B, dist a c < r → ∀ b ∈ B, dist b c < r →
      ¬ 2 * t ≤ ⟪n, shortestLift (b - a)⟫ := by
    intro a ha har b hb hbr hh
    have hh' := ordered_density_normal_oscillation hE hμ hN hpolar hn hnorm hr hr16 ht htr
      hδ har hbr (hd a ha t ht htR).2 (hd b hb t ht htR).1 hh
    rw [hquot] at hh'
    exact (not_lt_of_ge hh') hosc
  intro y hy hyr
  have hcc : dist c c < r := by simpa only [dist_self] using hr
  have hl : ⟪n, shortestLift (y - c)⟫ < 2 * t := lt_of_not_ge (hforbid c hc hcc y hy hyr)
  have he : shortestLift (c - y) = -shortestLift (y - c) := by
    apply shortestLift_eq_of_lift
    · rw [quotientMap_neg, quotientMap_shortestLift]; abel
    · rw [norm_neg, norm_shortestLift, ← dist_eq_norm]
      linarith
  have hk := lt_of_not_ge (hforbid y hy hyr c hc hcc)
  rw [he, inner_neg_right] at hk
  have habs : |⟪n, shortestLift (y - c)⟫| < 2 * t := abs_lt.mpr ⟨by linarith, hl⟩
  apply habs.trans_le
  dsimp [t]
  nlinarith

theorem isMinimizerAt_quantitative_trapping {V : ℝ} (hV : V ∈ Ioo 0 1)
    {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E) :
    ∃ R δ : ℝ, 0 < R ∧ 0 < δ ∧ ∀ μ : FiniteMeasure NormalBundle,
      IsNormalMeasure E μ → ∀ N : Torus → Cover, Measurable N →
      (∀ᵐ z ∂(μ : Measure NormalBundle), N (quotientMap z.1) = (z.2 : Cover)) →
      (∀ᵐ x ∂(spatialNormalMeasure μ : Measure Torus), ‖N x‖ = 1) →
      ∀ c ∈ frontier (openRepresentative E), ∀ n : Cover, ‖n‖ = 1 →
      ∀ r ε : ℝ, 0 < r → r ≤ R → 0 < ε → ε ≤ 1/4 →
        131072*normalOscillation (spatialNormalMeasure μ) N c n (8*r) < δ^2*(ε/4)^6 →
        normalCap c n r (ε*r) ⊆ (closure (openRepresentative E))ᶜ ∧
        normalCap c (-n) r (ε*r) ⊆ openRepresentative E := by
  obtain ⟨R,δ,hR,hδ,hd⟩ := isMinimizerAt_two_sided_density hV hE hmin
  refine ⟨min R (1/16),δ,by positivity,hδ,?_⟩
  intro μ hμ N hN hp hn c hc n hnorm r ε hr hrs hε hεs hosc
  have hrR := hrs.trans (min_le_left _ _)
  have hr16 := hrs.trans (min_le_right _ _)
  have hbc : c ∈ volumeSupport E ∩ volumeSupport Eᶜ := by
    rwa [isMinimizerAt_frontier_openRepresentative hV hE hmin] at hc
  have hflat := small_oscillation_boundary_flat hE hμ hN hp hn hδ hd hbc hnorm
    hr hrR hr16 hε (by linarith) hosc
  have hflatU : ∀ y ∈ frontier (openRepresentative E), dist y c < r →
      |⟪n,shortestLift (y-c)⟫| < ε*r := by
    rwa [isMinimizerAt_frontier_openRepresentative hV hE hmin]
  have hthreshold : δ^2*(ε/4)^6 ≤ δ^2*(1/8)^6 := by
    apply mul_le_mul_of_nonneg_left _ (sq_nonneg _)
    exact pow_le_pow_left₀ (by positivity) (by linarith) 6
  have hout := small_oscillation_outward_cap hE (isOpen_openRepresentative E)
    (isMinimizerAt_openRepresentative_ae hV hE hmin) hμ hN hp hn hnorm hr hr16 hεs hδ
    (hd c hbc (r/8) (by positivity) (by linarith)).2 hflatU (hosc.trans_le hthreshold)
  have hVc : 1-V ∈ Ioo (0:ℝ) 1 := ⟨by linarith [hV.2],by linarith [hV.1]⟩
  have hminc := (isMinimizerAt_compl ⟨hV.1.le,hV.2.le⟩).mpr hmin
  have hn' : ∀ᵐ x ∂(spatialNormalMeasure (μ.map reverseNormal) : Measure Torus), ‖-N x‖ = 1 := by
    simpa only [spatialNormalMeasure_reverse,norm_neg] using hn
  have heq : frontier (openRepresentative Eᶜ) = frontier (openRepresentative E) := by
    rw [isMinimizerAt_frontier_openRepresentative hVc hE.compl hminc,
      isMinimizerAt_frontier_openRepresentative hV hE hmin,compl_compl,inter_comm]
  have hflatC : ∀ y ∈ frontier (openRepresentative Eᶜ), dist y c < r →
      |⟪-n,shortestLift (y-c)⟫| < ε*r := by
    simpa only [heq,inner_neg_left,abs_neg] using hflatU
  have hosceq : normalOscillation (spatialNormalMeasure (μ.map reverseNormal)) (-N) c (-n) (8*r) =
      normalOscillation (spatialNormalMeasure μ) N c n (8*r) := by
    simp only [normalOscillation,spatialNormalMeasure_reverse,Pi.neg_apply,neg_sub_neg,norm_sub_rev n]
  have hin := small_oscillation_outward_cap hE.compl (isOpen_openRepresentative Eᶜ)
    (isMinimizerAt_openRepresentative_ae hVc hE.compl hminc) (isNormalMeasure_compl hE hμ) hN.neg
    (polar_reverse_normal hN hp) hn' (by simpa only [norm_neg] using hnorm) hr hr16 hεs hδ
    (by simpa only [compl_compl] using (hd c hbc (r/8) (by positivity) (by linarith)).1)
    hflatC (by rw [hosceq]; exact hosc.trans_le hthreshold)
  have he : (closure (openRepresentative Eᶜ))ᶜ = openRepresentative E := by
    rw [isMinimizerAt_closure_openRepresentative hVc hE.compl hminc]
    rfl
  exact ⟨hout,he ▸ hin⟩

end CubicTorus

end
end

section

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

lemma characteristic_symmDiff_abs (E F : Set Torus) (x : Torus) :
    |characteristic F x - characteristic E x| = characteristic (E ∆ F) x := by
  classical
  by_cases he : x ∈ E <;> by_cases hf : x ∈ F <;>
    simp [characteristic, Set.mem_symmDiff, he, hf]

theorem cutoff_gluing_flux_le {E F : Set Torus}
    (hE : MeasurableSet E) (hF : MeasurableSet F)
    {μ ν : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) (hν : IsNormalMeasure F ν)
    {w : Cover → ℝ} (hw : ContDiff ℝ (⊤ : ℕ∞) w)
    (hp : ∀ n x, w (x + latticeVector n) = w x) (hb : ∀ x, w x ∈ Icc 0 1)
    {X : Cover → Cover} (hX : AdmissibleField X) :
    (∫ x in fundamentalCube,
      ((1 - w x) * characteristic E (quotientMap x) + w x * characteristic F (quotientMap x)) *
        divergence X x) ≤
      (∫ z, 1 - w z.1 ∂(μ : Measure NormalBundle)) +
      (∫ z, w z.1 ∂(ν : Measure NormalBundle)) +
      ∫ x in fundamentalCube ∩ quotientMap ⁻¹' (E ∆ F), ‖gradient w x‖ := by
  let Y : Cover → Cover := fun x ↦ (1 - w x) • X x
  let Z : Cover → Cover := fun x ↦ w x • X x
  have hY : AdmissibleField Y := admissible_cutoff (contDiff_const.sub hw)
    (fun n x ↦ by rw [hp]) (fun x ↦ by constructor <;> linarith [(hb x).1, (hb x).2]) hX
  have hZ : AdmissibleField Z := admissible_cutoff hw hp hb hX
  let a : Cover → ℝ := fun x ↦ characteristic E (quotientMap x) * divergence Y x
  let b : Cover → ℝ := fun x ↦ characteristic F (quotientMap x) * divergence Z x
  let c : Cover → ℝ := fun x ↦ (characteristic F (quotientMap x) - characteristic E (quotientMap x)) *
    ⟪gradient w x, X x⟫
  have ha : IntegrableOn a fundamentalCube := integrableOn_characteristic_mul hE.nullMeasurableSet
    (integrableOn_divergence hY.1)
  have hb' : IntegrableOn b fundamentalCube := integrableOn_characteristic_mul hF.nullMeasurableSet
    (integrableOn_divergence hZ.1)
  have hi : IntegrableOn (fun x ↦ ⟪gradient w x, X x⟫) fundamentalCube :=
    integrableOn_periodic_continuous ((gradient_contDiff hw).continuous.inner hX.1.continuous)
      (fun n x ↦ by rw [gradient_periodic hp, hX.2.1])
  have hc : IntegrableOn c fundamentalCube := by
    have hh := (integrableOn_characteristic_mul hF.nullMeasurableSet hi).sub
      (integrableOn_characteristic_mul hE.nullMeasurableSet hi)
    simpa only [Pi.sub_def, ← sub_mul, c] using hh
  have hgn : IntegrableOn (fun x ↦ ‖gradient w x‖) fundamentalCube :=
    integrableOn_periodic_continuous (gradient_contDiff hw).continuous.norm
      (fun n x ↦ by rw [gradient_periodic hp])
  have heq (x : Cover) :
      ((1 - w x) * characteristic E (quotientMap x) + w x * characteristic F (quotientMap x)) *
        divergence X x = a x + b x - c x := by
    dsimp [a, b, c, Y, Z]
    rw [divergence_smul_function ((contDiff_const.sub hw).differentiable (by simp)).differentiableAt
      (hX.1.differentiable (by simp)).differentiableAt,
      divergence_smul_function (hw.differentiable (by simp)).differentiableAt
      (hX.1.differentiable (by simp)).differentiableAt,
      gradient_const_sub, inner_neg_left]
    ring
  simp_rw [heq]
  have hab : IntegrableOn (fun x ↦ a x + b x) fundamentalCube := by
    simpa only [Pi.add_def] using ha.add hb'
  rw [integral_sub hab hc, integral_add ha hb']
  have hmassE : (∫ x in fundamentalCube, a x) ≤ ∫ z, 1 - w z.1 ∂(μ : Measure NormalBundle) := by
    dsimp only [a]
    simp_rw [characteristic_mul]
    rw [lift_indicator_integral hE.nullMeasurableSet,
      ← normalMeasure_weighted_flux hμ (contDiff_const.sub hw) (fun n x ↦ by rw [hp]) hX]
    have hh : Continuous (fun z : NormalBundle ↦ 1 - w z.1) := by fun_prop
    apply integral_mono ((hh.mul (normalTest X hX.1.continuous).continuous).integrable_of_hasCompactSupport
      (HasCompactSupport.of_compactSpace _))
      (hh.integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _))
    intro z
    exact mul_le_of_le_one_right (by linarith [(hb z.1).2]) (normalTest_le_one hX z)
  have hmassF : (∫ x in fundamentalCube, b x) ≤ ∫ z, w z.1 ∂(ν : Measure NormalBundle) := by
    dsimp only [b]
    simp_rw [characteristic_mul]
    rw [lift_indicator_integral hF.nullMeasurableSet, ← normalMeasure_weighted_flux hν hw hp hX]
    have hh : Continuous (fun z : NormalBundle ↦ w z.1) := by fun_prop
    apply integral_mono ((hh.mul (normalTest X hX.1.continuous).continuous).integrable_of_hasCompactSupport
      (HasCompactSupport.of_compactSpace _))
      (hh.integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _))
    intro z
    exact mul_le_of_le_one_right (hb z.1).1 (normalTest_le_one hX z)
  have herr : -(∫ x in fundamentalCube, c x) ≤
      ∫ x in fundamentalCube ∩ quotientMap ⁻¹' (E ∆ F), ‖gradient w x‖ := by
    rw [← integral_neg, ← lift_indicator_integral (hE.symmDiff hF).nullMeasurableSet]
    have hci := integrableOn_characteristic_mul (hE.symmDiff hF).nullMeasurableSet hgn
    simp_rw [← characteristic_mul] at ⊢ hci
    apply integral_mono hc.neg hci
    intro x
    calc
      -c x ≤ |c x| := neg_le_abs _
      _ = characteristic (E ∆ F) (quotientMap x) * |⟪gradient w x, X x⟫| := by
        dsimp only [c]
        rw [abs_mul, characteristic_symmDiff_abs]
      _ ≤ characteristic (E ∆ F) (quotientMap x) * ‖gradient w x‖ := by
        apply mul_le_mul_of_nonneg_left _ (characteristic_nonneg _ _)
        exact (abs_real_inner_le_norm _ _).trans
          (mul_le_of_le_one_right (norm_nonneg _) (hX.2.2 x))
  linarith

end CubicTorus

end
end

section

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

def gluedRegion (E F B : Set Torus) : Set Torus := (E \ B) ∪ (F ∩ B)

lemma measurableSet_gluedRegion {E F B : Set Torus}
    (hE : MeasurableSet E) (hF : MeasurableSet F) (hB : MeasurableSet B) :
    MeasurableSet (gluedRegion E F B) := (hE.diff hB).union (hF.inter hB)

lemma characteristic_gluedRegion (E F B : Set Torus) (x : Torus) :
    characteristic (gluedRegion E F B) x =
      (1 - characteristic B x) * characteristic E x + characteristic B x * characteristic F x := by
  classical
  by_cases he : x ∈ E <;> by_cases hf : x ∈ F <;> by_cases hb : x ∈ B <;>
    simp [characteristic, gluedRegion, he, hf, hb]

lemma cutoff_gluing_flux_tendsto {E F B : Set Torus}
    (hE : MeasurableSet E) (hF : MeasurableSet F) (hB : MeasurableSet B)
    {w : ℕ → Cover → ℝ} (hw : ∀ i, Continuous (w i))
    (hb : ∀ i x, w i x ∈ Icc (0 : ℝ) 1)
    (ht : ∀ x, Tendsto (fun i ↦ w i x) atTop (𝓝 (characteristic B (quotientMap x))))
    {X : Cover → Cover} (hX : AdmissibleField X) :
    Tendsto (fun i ↦ ∫ x in fundamentalCube,
      ((1 - w i x) * characteristic E (quotientMap x) + w i x * characteristic F (quotientMap x)) *
        divergence X x) atTop
      (𝓝 (∫ x in fundamentalCube ∩ quotientMap ⁻¹' gluedRegion E F B, divergence X x)) := by
  have hg := measurableSet_gluedRegion hE hF hB
  have he : Measurable (fun x : Cover ↦ characteristic E (quotientMap x)) :=
    (measurable_characteristic hE).comp measurable_quotientMap
  have hf : Measurable (fun x : Cover ↦ characteristic F (quotientMap x)) :=
    (measurable_characteristic hF).comp measurable_quotientMap
  have hlim := tendsto_integral_of_dominated_convergence
    (μ := volume.restrict fundamentalCube) (bound := fun x ↦ |divergence X x|)
    (F := fun i x ↦ ((1 - w i x) * characteristic E (quotientMap x) +
      w i x * characteristic F (quotientMap x)) * divergence X x)
    (f := fun x ↦ characteristic (gluedRegion E F B) (quotientMap x) * divergence X x)
    (fun i ↦ ((((measurable_const.sub (hw i).measurable).mul he).add
      ((hw i).measurable.mul hf)).mul (continuous_divergence hX.1).measurable).aestronglyMeasurable)
    (integrableOn_divergence hX.1).abs (fun i ↦ Eventually.of_forall fun x ↦ ?_)
    (Eventually.of_forall fun x ↦ ?_)
  · simpa only [characteristic_mul, lift_indicator_integral hg.nullMeasurableSet] using hlim
  · rw [Real.norm_eq_abs, abs_mul]
    apply mul_le_of_le_one_left (abs_nonneg _)
    have he0 := characteristic_nonneg E (quotientMap x)
    have hf0 := characteristic_nonneg F (quotientMap x)
    have he1 := (le_abs_self _).trans (characteristic_bound E (quotientMap x))
    have hf1 := (le_abs_self _).trans (characteristic_bound F (quotientMap x))
    have hw0 := (hb i x).1
    have hw1 := (hb i x).2
    rw [abs_of_nonneg (by positivity)]
    calc
      _ ≤ (1 - w i x) * 1 + w i x * 1 := add_le_add
        (mul_le_mul_of_nonneg_left he1 (by linarith)) (mul_le_mul_of_nonneg_left hf1 hw0)
      _ = 1 := by ring
  · rw [characteristic_gluedRegion]
    exact (((tendsto_const_nhds.sub (ht x)).mul tendsto_const_nhds).add
      ((ht x).mul tendsto_const_nhds)).mul tendsto_const_nhds

lemma normalMeasure_sublevelCutoff_tendsto (μ : FiniteMeasure NormalBundle)
    {q : Cover → ℝ} (hq : Continuous q) (hp : ∀ n x, q (x + latticeVector n) = q x)
    {ε : ℕ → ℝ} (hε : ∀ i, 0 < ε i) (hεlim : Tendsto ε atTop (𝓝 0)) (t : ℝ) :
    Tendsto (fun i ↦ ∫ z : NormalBundle, sublevelCutoff q t (ε i) z.1 ∂(μ : Measure NormalBundle))
      atTop (𝓝 ((μ : Measure NormalBundle).real {z | q z.1 < t})) := by
  have hh := tendsto_integral_of_dominated_convergence
    (μ := (μ : Measure NormalBundle)) (bound := fun _ ↦ (1 : ℝ))
    (F := fun i z ↦ sublevelCutoff q t (ε i) z.1)
    (f := {z : NormalBundle | q z.1 < t}.indicator (fun _ ↦ (1 : ℝ)))
    (fun i ↦ (show Continuous (fun z : NormalBundle ↦ sublevelCutoff q t (ε i) z.1) from by
      unfold sublevelCutoff; fun_prop).aestronglyMeasurable)
    (integrable_const 1) (fun i ↦ Eventually.of_forall fun z ↦ by
      rw [Real.norm_eq_abs, abs_of_nonneg (sublevelCutoff_mem_Icc q t (ε i) z.1).1]
      exact (sublevelCutoff_mem_Icc q t (ε i) z.1).2)
    (Eventually.of_forall fun z ↦ ?_)
  · have hm : MeasurableSet {z : NormalBundle | q z.1 < t} :=
      isOpen_lt (by fun_prop) continuous_const |>.measurableSet
    simpa only [integral_indicator hm, integral_const, smul_eq_mul, mul_one,
      Measure.real_def, Measure.restrict_apply_univ] using hh
  · have he : characteristic (sublevelRegion q t) (quotientMap z.1) =
        {z : NormalBundle | q z.1 < t}.indicator (fun _ ↦ (1 : ℝ)) z := by
      classical
      by_cases hz : q z.1 < t <;> simp [characteristic, mem_sublevelRegion_quotient hp, hz]
    rw [← he]
    exact sublevelCutoff_tendsto hp hε hεlim t z.1

lemma normalMeasure_integral_one (μ : FiniteMeasure NormalBundle) :
    (∫ _ : NormalBundle, (1 : ℝ) ∂(μ : Measure NormalBundle)) = (μ.mass : ℝ) := by
  simp only [integral_const, smul_eq_mul, mul_one, Measure.real_def,
    ← FiniteMeasure.ennreal_mass, ENNReal.coe_toReal]

theorem perimeter_glued_sublevel_le {E F : Set Torus}
    (hE : MeasurableSet E) (hF : MeasurableSet F)
    {μ ν : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) (hν : IsNormalMeasure F ν)
    {q : Cover → ℝ} (hq : ContDiff ℝ (⊤ : ℕ∞) q)
    (hp : ∀ n x, q (x + latticeVector n) = q x)
    {K M t d : ℝ} (hK : ∀ u, ‖deriv Real.smoothTransition u‖ ≤ K)
    (hgrad : ∀ x, q x < t → ‖gradient q x‖ ≤ M)
    (hd : HasDerivAt (sublevelVolume (E ∆ F) q) d t) :
    FinitePerimeter (gluedRegion E F (sublevelRegion q t)) ∧
      (perimeter (gluedRegion E F (sublevelRegion q t))).toReal ≤
        (μ.mass : ℝ) - (μ : Measure NormalBundle).real {z | q z.1 < t} +
        (ν : Measure NormalBundle).real {z | q z.1 < t} + K * M * d := by
  let ε : ℕ → ℝ := fun i ↦ 1 / ((i : ℝ) + 1)
  have he : ∀ i, 0 < ε i := fun i ↦ by dsimp [ε]; positivity
  have helim : Tendsto ε atTop (𝓝 0) := tendsto_one_div_add_atTop_nhds_zero_nat
  let w : ℕ → Cover → ℝ := fun i ↦ sublevelCutoff q t (ε i)
  have hw (i : ℕ) : ContDiff ℝ (⊤ : ℕ∞) (w i) := sublevelCutoff_contDiff hq t (ε i)
  have hwp (i : ℕ) : ∀ n x, w i (x + latticeVector n) = w i x := sublevelCutoff_periodic hp t (ε i)
  have hwb (i : ℕ) (x : Cover) : w i x ∈ Icc (0 : ℝ) 1 := sublevelCutoff_mem_Icc q t (ε i) x
  have hB := measurableSet_sublevelRegion hq.continuous.measurable t
  have hG := measurableSet_gluedRegion hE hF hB
  let A : ℝ := (μ.mass : ℝ) - (μ : Measure NormalBundle).real {z | q z.1 < t} +
    (ν : Measure NormalBundle).real {z | q z.1 < t} + K * M * d
  have hμlim : Tendsto (fun i ↦ ∫ z : NormalBundle, 1 - w i z.1 ∂(μ : Measure NormalBundle))
      atTop (𝓝 ((μ.mass : ℝ) - (μ : Measure NormalBundle).real {z | q z.1 < t})) := by
    have hh := (tendsto_const_nhds (x := (μ.mass : ℝ)) (f := atTop)).sub
      (normalMeasure_sublevelCutoff_tendsto μ hq.continuous hp he helim t)
    convert hh using 1
    funext i
    have hi : Integrable (fun z : NormalBundle ↦ w i z.1) (μ : Measure NormalBundle) :=
      (show Continuous (fun z : NormalBundle ↦ w i z.1) from by fun_prop).integrable_of_hasCompactSupport
        (HasCompactSupport.of_compactSpace _)
    rw [integral_sub (integrable_const 1) hi, normalMeasure_integral_one]
  have hνlim := normalMeasure_sublevelCutoff_tendsto ν hq.continuous hp he helim t
  have hdlim := tendsto_backward_quotient_of_hasDerivAt hd he helim
  have hright : Tendsto (fun i ↦
      (∫ z : NormalBundle, 1 - w i z.1 ∂(μ : Measure NormalBundle)) +
      (∫ z : NormalBundle, w i z.1 ∂(ν : Measure NormalBundle)) +
      K * M * ((sublevelVolume (E ∆ F) q t - sublevelVolume (E ∆ F) q (t - ε i)) / ε i))
        atTop (𝓝 A) := (hμlim.add hνlim).add (tendsto_const_nhds.mul hdlim)
  have hbound (X : Cover → Cover) (hX : AdmissibleField X) :
      (∫ x in fundamentalCube ∩ quotientMap ⁻¹' gluedRegion E F (sublevelRegion q t), divergence X x) ≤ A := by
    have hleft := cutoff_gluing_flux_tendsto hE hF hB (fun i ↦ (hw i).continuous) hwb
      (sublevelCutoff_tendsto hp he helim t) hX
    apply le_of_tendsto_of_tendsto' hleft hright
    intro i
    exact (cutoff_gluing_flux_le hE hF hμ hν (hw i) (hwp i) (hwb i) hX).trans
      (add_le_add_right (sublevelCutoff_gradient_integral_le (hE.symmDiff hF) hq hp hK hgrad (he i)) _)
  have hA : 0 ≤ A := by
    simpa only [divergence_zero, integral_zero] using hbound (fun _ ↦ 0) admissible_zero
  have hb : perimeter (gluedRegion E F (sublevelRegion q t)) ≤ ENNReal.ofReal A := by
    apply iSup_le
    intro X
    apply iSup_le
    intro hX
    exact ENNReal.ofReal_le_ofReal (hbound X hX)
  refine ⟨⟨hG.nullMeasurableSet, hb.trans_lt ENNReal.ofReal_lt_top⟩, ?_⟩
  simpa only [ENNReal.toReal_ofReal hA] using ENNReal.toReal_mono ENNReal.ofReal_ne_top hb

lemma regionDistance_gluedRegion {E F B : Set Torus}
    (hE : NullMeasurableSet E torusVolume) (hF : NullMeasurableSet F torusVolume)
    (hB : NullMeasurableSet B torusVolume) :
    regionDistance E (gluedRegion E F B) = torusVolume.real ((E ∆ F) ∩ B) := by
  have heq (x : Torus) : ‖characteristic E x - characteristic (gluedRegion E F B) x‖ =
      characteristic ((E ∆ F) ∩ B) x := by
    classical
    by_cases he : x ∈ E <;> by_cases hf : x ∈ F <;> by_cases hb : x ∈ B <;>
      simp [characteristic, gluedRegion, Set.mem_symmDiff, he, hf, hb]
  unfold regionDistance
  simp_rw [heq]
  exact integral_characteristic ((hE.symmDiff hF).inter hB)

theorem isMinimizerAt_local_replacement {V : ℝ} (hV : V ∈ Ioo 0 1)
    {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E)
    {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) :
    ∃ η C : ℝ, 0 < η ∧ 0 ≤ C ∧ ∀ (F : Set Torus), MeasurableSet F →
      ∀ (ν : FiniteMeasure NormalBundle), IsNormalMeasure F ν →
      ∀ (q : Cover → ℝ), ContDiff ℝ (⊤ : ℕ∞) q →
      (∀ n x, q (x + latticeVector n) = q x) →
      ∀ K M t d : ℝ, (∀ u, ‖deriv Real.smoothTransition u‖ ≤ K) →
      (∀ x, q x < t → ‖gradient q x‖ ≤ M) →
      HasDerivAt (sublevelVolume (E ∆ F) q) d t → sublevelVolume (E ∆ F) q t < η →
      (μ : Measure NormalBundle).real {z | q z.1 < t} ≤
        (ν : Measure NormalBundle).real {z | q z.1 < t} + K * M * d +
          C * sublevelVolume (E ∆ F) q t := by
  obtain ⟨η, C, hη, hC, hc⟩ := isMinimizerAt_local_quasiminimal hV hmin
  refine ⟨η, C, hη, hC, ?_⟩
  intro F hF ν hν q hq hp K M t d hK hgrad hd ht
  obtain ⟨hG, hbound⟩ := perimeter_glued_sublevel_le hE hF hμ hν hq hp hK hgrad hd
  have hdist : regionDistance E (gluedRegion E F (sublevelRegion q t)) =
      sublevelVolume (E ∆ F) q t := regionDistance_gluedRegion hE.nullMeasurableSet
        hF.nullMeasurableSet (measurableSet_sublevelRegion hq.continuous.measurable t).nullMeasurableSet
  have hcomp := hc _ hG (hdist ▸ ht)
  rw [hdist] at hcomp
  rw [hμ.1] at hbound
  linarith

end CubicTorus

end
end

section

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

lemma BoundaryFlatAt.exists_small_cone {B : Set Torus} {c : Torus} {n : Cover}
    (hf : BoundaryFlatAt B c n) {ε : ℝ} (hε : 0 < ε) :
    ∃ R : ℝ, 0 < R ∧ ∀ y ∈ B, dist y c < R →
      |⟪n, shortestLift (y - c)⟫| ≤ ε * dist y c := by
  obtain ⟨R, hR, heR⟩ := Metric.mem_nhdsWithin_iff.mp (hf (ε / 2) (by positivity))
  refine ⟨R / 2, by positivity, ?_⟩
  intro y hy hyr
  by_cases hyc : y = c
  · subst y
    have hz : shortestLift (0 : Torus) = 0 := shortestLift_eq_of_lift rfl (by norm_num)
    simp [hz]
  · have hd : 0 < dist y c := dist_pos.mpr hyc
    have hh := heR ⟨(show dist (2 * dist y c) 0 < R by
        rw [Real.dist_eq, sub_zero, abs_of_pos (by positivity)]; linarith),
      (show 2 * dist y c ∈ Ioi (0 : ℝ) by change 0 < 2 * dist y c; positivity)⟩
    have hh' := hh y hy (by linarith)
    nlinarith

lemma BoundaryFlatAt.hasFDerivWithinAt_inner_zero
    {X : Type*} [NormedAddCommGroup X] [NormedSpace ℝ X]
    {f : X → Cover} {K : ℝ≥0} (hf : LipschitzWith K f)
    {B : Set Torus} {S : Set X} {a : Torus} {x : X} {n : Cover}
    (hS : ∀ y ∈ S, a + quotientMap (f y) ∈ B)
    (hflat : BoundaryFlatAt B (a + quotientMap (f x)) n) :
    HasFDerivWithinAt (fun y ↦ ⟪n, f y⟫) (0 : X →L[ℝ] ℝ) S x := by
  rw [hasFDerivWithinAt_iff_isLittleO, Asymptotics.isLittleO_iff]
  intro ε hε
  have hK : 0 < (K : ℝ) + 1 := by positivity
  obtain ⟨R, hR, hcone⟩ := hflat.exists_small_cone (div_pos hε hK)
  have hlocal : ∀ᶠ y in 𝓝 x, f y ∈ Metric.ball (f x) (min R (1 / 2)) :=
    hf.continuous.continuousAt.eventually (Metric.ball_mem_nhds _ (lt_min hR (by norm_num)))
  filter_upwards [self_mem_nhdsWithin, mem_nhdsWithin_of_mem_nhds hlocal] with y hy hyl
  have hdist : dist (a + quotientMap (f y)) (a + quotientMap (f x)) ≤ dist (f y) (f x) := by
    rw [dist_add_left]
    rw [dist_eq_norm, ← quotientMap_sub, dist_eq_norm]
    exact norm_quotientMap_le (f y - f x)
  have hsub : a + quotientMap (f y) - (a + quotientMap (f x)) = quotientMap (f y - f x) := by
    rw [quotientMap_sub]
    abel
  have hsmall : ‖f y - f x‖ < 1 / 2 := by
    rw [← dist_eq_norm]
    exact (show dist (f y) (f x) < min R (1 / 2) from hyl).trans_le (min_le_right _ _)
  have hh := hcone (a + quotientMap (f y)) (hS y hy)
    (hdist.trans_lt ((show dist (f y) (f x) < min R (1 / 2) from hyl).trans_le (min_le_left _ _)))
  rw [hsub, shortestLift_quotientMap hsmall] at hh
  have hb := hf.dist_le_mul y x
  have hc := mul_le_mul_of_nonneg_left (hdist.trans hb) (le_of_lt (div_pos hε hK))
  simp only [zero_apply, sub_zero, ← inner_sub_right, Real.norm_eq_abs]
  rw [← dist_eq_norm]
  calc
    |⟪n, f y - f x⟫| ≤ ε / ((K : ℝ) + 1) * dist (a + quotientMap (f y))
      (a + quotientMap (f x)) := hh
    _ ≤ ε / ((K : ℝ) + 1) * ((K : ℝ) * dist y x) := hc
    _ ≤ ε * dist y x := by
      have hk : (K : ℝ) / ((K : ℝ) + 1) ≤ 1 := (div_le_one hK).mpr (by linarith)
      have hh' := mul_le_mul_of_nonneg_left hk (mul_nonneg hε.le (dist_nonneg : 0 ≤ dist y x))
      calc
        _ = ε * dist y x * ((K : ℝ) / ((K : ℝ) + 1)) := by ring
        _ ≤ ε * dist y x * 1 := hh'
        _ = _ := mul_one _

lemma lipschitz_boundary_parameter_tangent
    {X : Type*} [NormedAddCommGroup X] [NormedSpace ℝ X] [FiniteDimensional ℝ X]
    [MeasurableSpace X] [BorelSpace X] (ν : Measure X) [Measure.IsAddHaarMeasure ν]
    {f : X → Cover} {K : ℝ≥0} (hf : LipschitzWith K f)
    {B : Set Torus} {S : Set X} {a : Torus} (N : X → Cover)
    (hS : ∀ y ∈ S, a + quotientMap (f y) ∈ B)
    (hflat : ∀ x ∈ S, BoundaryFlatAt B (a + quotientMap (f x)) (N x)) :
    ∀ᵐ x ∂ν, x ∈ S → (innerSL ℝ (N x)).comp (fderiv ℝ f x) = 0 := by
  let T := {x ∈ S | DifferentiableAt ℝ f x}
  let L : X → X →L[ℝ] ℝ := fun x ↦ (innerSL ℝ (N x)).comp (fderiv ℝ f x)
  have hL : ∀ x ∈ T, HasFDerivWithinAt (fun _ : X ↦ (0 : ℝ)) (L x) T x := by
    intro x hx
    have hd : HasFDerivWithinAt (fun y : X ↦ ⟪N x, f y⟫) (L x) T x :=
      ((innerSL ℝ (N x)).hasFDerivAt.comp x hx.2.hasFDerivAt).hasFDerivWithinAt
    have hz := (hflat x hx.1).hasFDerivWithinAt_inner_zero hf
      (fun y hy ↦ hS y hy.1) (S := T)
    convert hd.sub hz using 1
    all_goals first | rfl | (funext y; simp) | simp [L]
  have hae := ae_constant_derivative_eq_zero ν T L hL
  filter_upwards [hae, hf.ae_differentiableAt (μ := ν)] with x hx hd
  exact fun hs ↦ hx ⟨hs, hd⟩

lemma normalGraph_hasFDerivAt {n : Cover} {g : Plane → ℝ} {y : Plane}
    (hg : DifferentiableAt ℝ g y) :
    HasFDerivAt (normalGraph n g)
      ((normalPlaneLinearIsometry n).toContinuousLinearMap + (fderiv ℝ g y).smulRight n) y := by
  exact (normalPlaneLinearIsometry n).toContinuousLinearMap.hasFDerivAt.add
    (hg.hasFDerivAt.smul_const n)

lemma normalGraph_tangent_ae {n : Cover} (hn : ‖n‖ = 1)
    {g : Plane → ℝ} {K : ℝ≥0} (hg : LipschitzWith K g)
    {B : Set Torus} {S : Set Plane} {a : Torus} (N : Plane → Cover)
    (hS : ∀ y ∈ S, a + quotientMap (normalGraph n g y) ∈ B)
    (hflat : ∀ x ∈ S, BoundaryFlatAt B (a + quotientMap (normalGraph n g x)) (N x)) :
    ∀ᵐ x ∂(volume : Measure Plane), x ∈ S → ∀ v : Plane,
      ⟪N x, normalPlaneEmbedding n v + (fderiv ℝ g x v) • n⟫ = 0 := by
  have hh := lipschitz_boundary_parameter_tangent volume (normalGraph_lipschitz hn hg) N hS hflat
  filter_upwards [hh, hg.ae_differentiableAt (μ := (volume : Measure Plane))] with x hx hd hs v
  have he := congrArg (fun q : Plane →L[ℝ] ℝ ↦ q v) (hx hs)
  rw [(normalGraph_hasFDerivAt hd).fderiv] at he
  exact he

end CubicTorus

end
end

end

end OAI