import Mathlib
import OAI.Geometry.CubicTorus.Profiles.NormalMap

namespace OAI

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

theorem isMinimizerAt_common_fixed_not_boundary {V : ℝ} (hV : V∈Ioo 0 1)
    {E : Set Torus} (hmin : IsMinimizerAt V E)
    (hR : ∀ i : Fin 3,E=ᵐ[torusVolume]((axisReflection i).torus ⁻¹' E))
    (x : Torus) (hfix : ∀ i : Fin 3,(axisReflection i).torus x=x) :
    x∉frontier (openRepresentative E) := by
  let F := toMeasurable torusVolume E
  have hF : MeasurableSet F := measurableSet_toMeasurable _ _
  have hae : F=ᵐ[torusVolume]E := hmin.1.1.toMeasurable_ae_eq
  have hmF := (isMinimizerAt_congr_ae hae).mpr hmin
  have hRF (i : Fin 3) : F=ᵐ[torusVolume]((axisReflection i).torus ⁻¹' F) :=
    hae.trans ((hR i).trans ((axisReflection i).measurePreserving.quasiMeasurePreserving.preimage_ae_eq hae.symm))
  intro hx
  have hxF : quotientMap (representative x)∈frontier (openRepresentative F) := by
    rw [quotientMap_representative,openRepresentative_congr_ae hae]
    exact hx
  obtain ⟨μ,H,N,hN,hp,hμ,haN,hb,hs,hj,hu⟩ := Periodic.isMinimizerAt_H1_translation_jacobi hV hF hmF
  have hz : N (representative x)=0 := by
    ext i
    exact isMinimizerAt_axis_fixed_normal_zero hV hF hmF i (hRF i) hμ hN hp haN
      (representative x) hxF (by rw [quotientMap_representative]; exact hfix i)
  have hunit : ‖N (representative x)‖=1 := (hb _ hxF).1.self_of_nhds
  rw [hz,norm_zero] at hunit
  norm_num at hunit

def octantVertex (b : Fin 3 → Bool) : Cover :=
  WithLp.toLp 2 (fun i ↦ if b i then (1/2 : ℝ) else 0)

lemma octantVertex_fixed (b : Fin 3 → Bool) (i : Fin 3) :
    (axisReflection i).torus (quotientMap (octantVertex b))=quotientMap (octantVertex b) := by
  classical
  have he : (axisReflection i).cover (octantVertex b)=octantVertex b+
      latticeVector (Pi.single i (if b i then (-1 : ℤ) else 0)) := by
    ext j
    rw [axisReflection_cover_apply,PiLp.add_apply]
    by_cases h : j=i
    · subst j
      simp only [ite_true,octantVertex,latticeVector,WithLp.ofLp_toLp,Pi.single_eq_same]
      cases b i <;> norm_num
    · simp [h,latticeVector,Pi.single_apply]
  rw [←(axisReflection i).commute,he,quotientMap_add,quotientMap_latticeVector,add_zero]

theorem isMinimizerAt_reflection_origin_vertices {V : ℝ} (hV : V∈Ioo 0 1)
    {E : Set Torus} (hmin : IsMinimizerAt V E)
    (hc : IsPreconnected (frontier (openRepresentative E))) :
    ∃ a : Torus,let F := (fun z : Torus ↦ z+a) ⁻¹' E
      (∀ i : Fin 3,F=ᵐ[torusVolume]((axisReflection i).torus ⁻¹' F)) ∧
      ∀ b : Fin 3 → Bool,quotientMap (octantVertex b)∉frontier (openRepresentative F) := by
  obtain ⟨a,ha⟩ := isMinimizerAt_common_reflection_origin hV hmin hc
  refine ⟨a,ha,?_⟩
  intro b
  exact isMinimizerAt_common_fixed_not_boundary hV (isMinimizerAt_translation hmin a)
    ha _ (octantVertex_fixed b)

end CubicTorus

end
end

section

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

def closedUpperOctant : Set Cover := {x | ∀ i : Fin 3,(1/2 : ℝ)≤x i ∧ x i≤1}

def octantContract (t : ℝ) (x : Cover) : Cover :=
  (1-t) • x+t • WithLp.toLp 2 (fun _ : Fin 3 ↦ (3/4 : ℝ))

lemma octantContract_apply (t : ℝ) (x : Cover) (i : Fin 3) :
    octantContract t x i=(1-t)*x i+t*(3/4 : ℝ) := rfl

lemma octantContract_mem {t : ℝ} (ht : t∈Ioo (0 : ℝ) 1)
    {x : Cover} (hx : x∈closedUpperOctant) : octantContract t x∈upperOctant := by
  intro i
  rw [octantContract_apply]
  have h1 := mul_nonneg (sub_nonneg.mpr ht.2.le) (sub_nonneg.mpr (hx i).1)
  have h2 := mul_nonneg (sub_nonneg.mpr ht.2.le) (sub_nonneg.mpr (hx i).2)
  constructor <;> nlinarith [ht.1]

lemma octantContract_mono {t : ℝ} (ht : t≤1) {b : Fin 3 → Bool} {x y : Cover}
    (hxy : OrientedCoordinateLE b x y) :
    OrientedCoordinateLE b (octantContract t x) (octantContract t y) := by
  intro i
  simp only [octantContract_apply]
  have hh := hxy i
  cases hbi : b i <;> simp only [hbi,Bool.false_eq_true,ite_false,ite_true] at hh ⊢
  · linarith [mul_le_mul_of_nonneg_left hh (sub_nonneg.mpr ht)]
  · linarith [mul_le_mul_of_nonneg_left hh (sub_nonneg.mpr ht)]

lemma octantContract_tendsto (x : Cover) :
    Tendsto (fun t : ℝ ↦ quotientMap (octantContract t x)) (𝓝[>]0) (𝓝 (quotientMap x)) := by
  have hc : Continuous (fun t : ℝ ↦ quotientMap (octantContract t x)) := by
    exact continuous_quotientMap.comp
      (((continuous_const.sub continuous_id).smul continuous_const).add
        (continuous_id.smul continuous_const))
  have hh := (hc.tendsto (0 : ℝ)).mono_left (nhdsWithin_le_nhds (s := Ioi (0 : ℝ)))
  simpa [octantContract] using hh

lemma octant_downset_closed_endpoint {O : Set Torus} (hO : IsOpen O)
    {b : Fin 3 → Bool}
    (hd : ∀ x∈upperOctant,∀ y∈upperOctant,OrientedCoordinateLE b x y →
      quotientMap y∈O → quotientMap x∈O)
    {x y : Cover} (hx : x∈closedUpperOctant) (hy : y∈closedUpperOctant)
    (hxy : OrientedCoordinateLE b x y) (hyo : quotientMap y∈O) :
    quotientMap x∈closure O := by
  have hyv : ∀ᶠ t in 𝓝[>](0 : ℝ),quotientMap (octantContract t y)∈O :=
    octantContract_tendsto y (hO.mem_nhds hyo)
  apply isClosed_closure.mem_of_tendsto (octantContract_tendsto x)
  filter_upwards [hyv,self_mem_nhdsWithin,(eventually_lt_nhds (show (0 : ℝ)<1 by norm_num)).filter_mono nhdsWithin_le_nhds]
    with t hty ht0 ht1
  exact subset_closure (hd _ (octantContract_mem ⟨ht0,ht1⟩ hx)
    _ (octantContract_mem ⟨ht0,ht1⟩ hy) (octantContract_mono ht1.le hxy) hty)

lemma octant_downset_nonboundary_endpoint {O : Set Torus} (hO : IsOpen O)
    {b : Fin 3 → Bool}
    (hd : ∀ x∈upperOctant,∀ y∈upperOctant,OrientedCoordinateLE b x y →
      quotientMap y∈O → quotientMap x∈O)
    {x y : Cover} (hx : x∈closedUpperOctant) (hy : y∈closedUpperOctant)
    (hxy : OrientedCoordinateLE b x y) (hyo : quotientMap y∈O)
    (hxb : quotientMap x∉frontier O) : quotientMap x∈O := by
  have hh := octant_downset_closed_endpoint hO hd hx hy hxy hyo
  by_contra hn
  apply hxb
  rw [hO.frontier_eq]
  exact ⟨hh,hn⟩

end CubicTorus

end
end

section

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

lemma LatticeIsometry.openRepresentative_preimage_null (e : LatticeIsometry)
    {E : Set Torus} (hE : NullMeasurableSet E torusVolume) :
    openRepresentative (e.torus ⁻¹' E)=e.torus ⁻¹' openRepresentative E := by
  have he := hE.toMeasurable_ae_eq
  have hp := e.measurePreserving.quasiMeasurePreserving.preimage_ae_eq he
  rw [←openRepresentative_congr_ae hp,e.openRepresentative_preimage (measurableSet_toMeasurable _ _),
    openRepresentative_congr_ae he]

lemma reflection_invariant_openRepresentative {E : Set Torus}
    (hE : NullMeasurableSet E torusVolume)
    (hR : ∀ i : Fin 3,E=ᵐ[torusVolume]((axisReflection i).torus ⁻¹' E)) :
    ∀ i : Fin 3,∀ z : Torus,(axisReflection i).torus z∈openRepresentative E ↔ z∈openRepresentative E := by
  intro i z
  have hh := openRepresentative_congr_ae (hR i)
  rw [(axisReflection i).openRepresentative_preimage_null hE] at hh
  exact (Set.ext_iff.mp hh z).symm

def octantFlipSet (s : Finset (Fin 3)) (x : Cover) : Cover :=
  WithLp.toLp 2 (fun i ↦ if i∈s then 1-x i else x i)

lemma octantFlipSet_empty (x : Cover) : octantFlipSet ∅ x=x := by
  ext i; simp [octantFlipSet]

lemma octantFlipSet_insert {s : Finset (Fin 3)} {i : Fin 3} (hi : i∉s) (x : Cover) :
    octantFlipSet (insert i s) x=(axisReflection i).cover (octantFlipSet s x)+
      latticeVector (Pi.single i (1 : ℤ)) := by
  ext j
  rw [PiLp.add_apply,axisReflection_cover_apply]
  by_cases hji : j=i
  · subst j
    simp [octantFlipSet,hi,latticeVector,Pi.single_eq_same]
    ring
  · simp [octantFlipSet,hji,latticeVector,Pi.single_apply]

lemma octantFlipSet_mem {O : Set Torus}
    (hR : ∀ i : Fin 3,∀ z : Torus,(axisReflection i).torus z∈O ↔ z∈O)
    (s : Finset (Fin 3)) (x : Cover) : quotientMap (octantFlipSet s x)∈O ↔ quotientMap x∈O := by
  classical
  induction s using Finset.induction_on with
  | empty => rw [octantFlipSet_empty]
  | @insert i s hi ih =>
    rw [octantFlipSet_insert hi,quotientMap_add,quotientMap_latticeVector,add_zero,
      (axisReflection i).commute,hR,ih]

lemma reflection_invariant_fold {O : Set Torus}
    (hR : ∀ i : Fin 3,∀ z : Torus,(axisReflection i).torus z∈O ↔ z∈O)
    {z : Torus} (hz : z∈O) : ∃ x∈closedUpperOctant,quotientMap x∈O := by
  classical
  let y := representative z
  let s : Finset (Fin 3) := Finset.univ.filter (fun i ↦ y i≤1/2)
  refine ⟨octantFlipSet s y,?_,?_⟩
  · intro i
    have hy := representative_mem_fundamentalCube z i
    change 0≤y i ∧ y i<1 at hy
    change (1/2 : ℝ)≤(if i∈s then 1-y i else y i) ∧ (if i∈s then 1-y i else y i)≤1
    have hs : (i∈s) ↔ y i≤1/2 := by simp only [s,Finset.mem_filter,Finset.mem_univ,true_and]
    by_cases hi : y i≤1/2
    · rw [ite_eq_left (hs.mpr hi)]; constructor <;> linarith [hy.1]
    · rw [ite_eq_right (fun h ↦ hi (hs.mp h))]; constructor <;> linarith [hy.2]
  · apply (octantFlipSet_mem hR s y).mpr
    simpa only [y,quotientMap_representative] using hz

lemma sibling_isMinimizerAt_openRepresentative_nonempty {V : ℝ} (hV : V∈Ioo 0 1)
    {E : Set Torus} (hmin : IsMinimizerAt V E) : (openRepresentative E).Nonempty := by
  let F := toMeasurable torusVolume E
  have hae : F=ᵐ[torusVolume]E := hmin.1.1.toMeasurable_ae_eq
  have hmF := (isMinimizerAt_congr_ae hae).mpr hmin
  have hO : openRepresentative E=ᵐ[torusVolume]E := by
    rw [←openRepresentative_congr_ae hae]
    exact (isMinimizerAt_openRepresentative_ae hV (measurableSet_toMeasurable _ _) hmF).trans hae
  by_contra hn
  have he := Set.not_nonempty_iff_eq_empty.mp hn
  have hm := measure_congr hO
  rw [he,measure_empty,hmin.2.1] at hm
  exact (ENNReal.ofReal_pos.mpr hV.1).ne' hm.symm

end CubicTorus

end
end

section

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

def upperVertex (c : Fin 3 → Bool) : Cover :=
  WithLp.toLp 2 (fun i ↦ if c i then (1 : ℝ) else 1/2)

def orientedUpperVertex (b c : Fin 3 → Bool) : Cover :=
  upperVertex (fun i ↦ if b i then c i else !c i)

lemma upperVertex_mem (c : Fin 3 → Bool) : upperVertex c∈closedUpperOctant := by
  intro i
  dsimp [upperVertex]
  cases c i <;> norm_num

lemma upperVertex_fixed (c : Fin 3 → Bool) (i : Fin 3) :
    (axisReflection i).torus (quotientMap (upperVertex c))=quotientMap (upperVertex c) := by
  have he : (axisReflection i).cover (upperVertex c)=upperVertex c+
      latticeVector (Pi.single i (if c i then (-2 : ℤ) else -1)) := by
    ext j
    rw [axisReflection_cover_apply,PiLp.add_apply]
    by_cases h : j=i
    · subst j
      simp only [ite_true,upperVertex,latticeVector,WithLp.ofLp_toLp,Pi.single_eq_same]
      cases c i <;> norm_num
    · simp [h,latticeVector,Pi.single_apply]
  rw [←(axisReflection i).commute,he,quotientMap_add,quotientMap_latticeVector,add_zero]

lemma orientedUpperVertex_min (b : Fin 3 → Bool) {x : Cover} (hx : x∈closedUpperOctant) :
    OrientedCoordinateLE b (orientedUpperVertex b (fun _ ↦ false)) x := by
  intro i
  dsimp [orientedUpperVertex,upperVertex]
  by_cases hbi : b i=true
  · simpa [hbi] using (hx i).1
  · simpa [hbi] using (hx i).2

lemma orientedUpperVertex_max (b : Fin 3 → Bool) {x : Cover} (hx : x∈closedUpperOctant) :
    OrientedCoordinateLE b x (orientedUpperVertex b (fun _ ↦ true)) := by
  intro i
  dsimp [orientedUpperVertex,upperVertex]
  by_cases hbi : b i=true
  · simpa [hbi] using (hx i).2
  · simpa [hbi] using (hx i).1

lemma orientedUpperVertex_mono (b : Fin 3 → Bool) {c d : Fin 3 → Bool}
    (hcd : ∀ i,c i=true → d i=true) :
    OrientedCoordinateLE b (orientedUpperVertex b c) (orientedUpperVertex b d) := by
  intro i
  dsimp [orientedUpperVertex,upperVertex]
  have hh := hcd i
  by_cases hbi : b i=true <;> by_cases hci : c i=true <;> by_cases hdi : d i=true <;> simp_all <;> norm_num

lemma isMinimizerAt_closure_openRepresentative_null {V : ℝ} (hV : V∈Ioo 0 1)
    {E : Set Torus} (hmin : IsMinimizerAt V E) :
    closure (openRepresentative E)=volumeSupport E := by
  let F := toMeasurable torusVolume E
  have hFE : F=ᵐ[torusVolume]E := hmin.1.1.toMeasurable_ae_eq
  rw [←openRepresentative_congr_ae hFE,←volumeSupport_congr_ae hFE]
  exact isMinimizerAt_closure_openRepresentative hV (measurableSet_toMeasurable _ _)
    ((isMinimizerAt_congr_ae hFE).mpr hmin)

theorem isMinimizerAt_vertex_order_ideal {V : ℝ} (hV : V∈Ioo 0 1)
    {E : Set Torus} (hmin : IsMinimizerAt V E)
    (hc : IsPreconnected (frontier (openRepresentative E)))
    (hR : ∀ i : Fin 3,E=ᵐ[torusVolume]((axisReflection i).torus ⁻¹' E)) :
    ∃ b : Fin 3 → Bool,
      quotientMap (orientedUpperVertex b (fun _ ↦ false))∈openRepresentative E ∧
      quotientMap (orientedUpperVertex b (fun _ ↦ true))∉openRepresentative E ∧
      (∀ c : Fin 3 → Bool,quotientMap (orientedUpperVertex b c)∉frontier (openRepresentative E)) ∧
      ∀ c d : Fin 3 → Bool,(∀ i,c i=true → d i=true) →
        quotientMap (orientedUpperVertex b d)∈openRepresentative E →
        quotientMap (orientedUpperVertex b c)∈openRepresentative E := by
  obtain ⟨b,hb⟩ := isMinimizerAt_octant_downset hV hmin hc hR
  have hno (c : Fin 3 → Bool) : quotientMap (orientedUpperVertex b c)∉frontier (openRepresentative E) :=
    isMinimizerAt_common_fixed_not_boundary hV hmin hR _ (upperVertex_fixed _)
  have hminv : quotientMap (orientedUpperVertex b (fun _ ↦ false))∈openRepresentative E := by
    obtain ⟨z,hz⟩ := sibling_isMinimizerAt_openRepresentative_nonempty hV hmin
    obtain ⟨y,hy,hyO⟩ := reflection_invariant_fold (reflection_invariant_openRepresentative hmin.1.1 hR) hz
    exact octant_downset_nonboundary_endpoint (isOpen_openRepresentative E) hb (upperVertex_mem _)
      hy (orientedUpperVertex_min b hy) hyO (hno _)
  have hmaxv : quotientMap (orientedUpperVertex b (fun _ ↦ true))∉openRepresentative E := by
    intro hh
    have hVc : 1-V∈Ioo (0 : ℝ) 1 := ⟨by linarith [hV.2],by linarith [hV.1]⟩
    have hmc := (isMinimizerAt_compl ⟨hV.1.le,hV.2.le⟩).mpr hmin
    have hRc (i : Fin 3) : Eᶜ=ᵐ[torusVolume]((axisReflection i).torus ⁻¹' Eᶜ) := (hR i).compl
    obtain ⟨z,hz⟩ := sibling_isMinimizerAt_openRepresentative_nonempty hVc hmc
    obtain ⟨y,hy,hyO⟩ := reflection_invariant_fold (reflection_invariant_openRepresentative hmc.1.1 hRc) hz
    have hcO := octant_downset_closed_endpoint (isOpen_openRepresentative E) hb hy
      (upperVertex_mem _) (orientedUpperVertex_max b hy) hh
    rw [isMinimizerAt_closure_openRepresentative_null hV hmin] at hcO
    exact hyO (by simpa only [compl_compl] using hcO)
  refine ⟨b,hminv,hmaxv,hno,?_⟩
  intro c d hcd hd
  exact octant_downset_nonboundary_endpoint (isOpen_openRepresentative E) hb (upperVertex_mem _)
    (upperVertex_mem _) (orientedUpperVertex_mono b hcd) hd (hno c)

end CubicTorus

end
end

section

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

lemma representative_quotientMap_coordinate {x : Cover} {i : Fin 3} (hx : x i∈Ico (0 : ℝ) 1) :
    representative (quotientMap x) i=x i := by
  change ((AddCircle.equivIco (1 : ℝ) 0) (x i : AddCircle (1 : ℝ)) : ℝ)=x i
  rw [AddCircle.equivIco_coe_of_mem (by simpa using hx)]

theorem isMinimizerAt_nonstandard_strict_octant {V : ℝ} (hV : V∈Ioc 0 (1/2))
    {E : Set Torus} (hmin : IsMinimizerAt V E)
    (hc : IsPreconnected (frontier (openRepresentative E)))
    (hstd : ¬StandardRegionAt V E)
    (hR : ∀ i : Fin 3,E=ᵐ[torusVolume]((axisReflection i).torus ⁻¹' E)) :
    ∃ (μ : FiniteMeasure NormalBundle) (H : ℝ) (N : Cover → Cover) (b : Fin 3 → Bool),
      IsNormalMeasure E μ ∧ ContDiff ℝ (⊤ : ℕ∞) N ∧
      (∀ m x,N (x+latticeVector m)=N x) ∧
      (∀ᵐ z ∂(μ : Measure NormalBundle),N z.1=(z.2 : Cover)) ∧
      (∀ x : Cover,quotientMap x∈frontier (openRepresentative E) →
        (∀ᶠ y in 𝓝 x,‖N y‖=1) ∧ divergence N x=H) ∧
      (∀ i : Fin 3,∀ x : Cover,x i∈Ioo (1/2 : ℝ) 1 →
        quotientMap x∈frontier (openRepresentative E) →
        if b i then 0<N x i else N x i<0) ∧
      (∀ x∈upperOctant,∀ y∈upperOctant,OrientedCoordinateLE b x y →
        quotientMap y∈openRepresentative E → quotientMap x∈openRepresentative E) := by
  classical
  have hV' : V∈Ioo (0 : ℝ) 1 := ⟨hV.1,by linarith [hV.2]⟩
  let F := toMeasurable torusVolume E
  have hF : MeasurableSet F := measurableSet_toMeasurable _ _
  have hFE : F=ᵐ[torusVolume]E := hmin.1.1.toMeasurable_ae_eq
  have hmF := (isMinimizerAt_congr_ae hFE).mpr hmin
  have hbd : frontier (openRepresentative F)=frontier (openRepresentative E) :=
    congrArg frontier (openRepresentative_congr_ae hFE)
  have hcF : IsPreconnected (frontier (openRepresentative F)) := by rwa [hbd]
  have hRF (i : Fin 3) : F=ᵐ[torusVolume]((axisReflection i).torus ⁻¹' F) :=
    hFE.trans ((hR i).trans ((axisReflection i).measurePreserving.quasiMeasurePreserving.preimage_ae_eq hFE.symm))
  obtain ⟨μ,H,N,hN,hp,hμ,haN,hb,hs,hj,hu⟩ := Periodic.isMinimizerAt_H1_translation_jacobi hV' hF hmF
  have hb' (x : Cover) (hx : quotientMap x∈frontier (openRepresentative F)) :
      (∀ᶠ y in 𝓝 x,‖N y‖=1) ∧ divergence N x=H := ⟨(hb x hx).1,(hb x hx).2.1⟩
  have hbE : ∀ x : Cover,quotientMap x∈frontier (openRepresentative E) →
      (∀ᶠ y in 𝓝 x,‖N y‖=1) ∧ divergence N x=H := by rwa [hbd] at hb'
  have hμE := hμ.congr_ae hFE
  have hsg (i : Fin 3) : ∃ bi : Bool,∀ x : Cover,x i∈Ioo (1/2 : ℝ) 1 →
      quotientMap x∈frontier (openRepresentative E) → if bi then 0<N x i else N x i<0 := by
    rcases isMinimizerAt_axis_strict_normal_sign hV' hF hmF hcF i (hRF i) hμ hN hp haN with hz|hn|hp'
    · exfalso
      have hzE : ∀ x∈frontier (openRepresentative E),N (representative x) i=0 := by rwa [hbd] at hz
      obtain ⟨hlo,hhi,hcong⟩ := isMinimizerAt_zero_axis_standard hV hmin hc hμE hN hp haN hbE i hzE
      apply hstd
      unfold StandardRegionAt SmallStandardRegion
      rw [ite_eq_left hV.2]
      exact Or.inr (Or.inl ⟨hlo,hhi,hcong⟩)
    · refine ⟨false,fun x hx hxb ↦ ?_⟩
      have hh := hn (quotientMap x) (by rwa [hbd]) (by
        rw [representative_quotientMap_coordinate ⟨by linarith [hx.1],hx.2⟩]
        exact (firstSeam_sign ⟨by linarith [hx.1],hx.2⟩).mpr hx.1)
      simpa only [Bool.false_eq_true,ite_false,periodic_representative hp x] using hh
    · refine ⟨true,fun x hx hxb ↦ ?_⟩
      have hh := hp' (quotientMap x) (by rwa [hbd]) (by
        rw [representative_quotientMap_coordinate ⟨by linarith [hx.1],hx.2⟩]
        exact (firstSeam_sign ⟨by linarith [hx.1],hx.2⟩).mpr hx.1)
      simpa only [ite_true,periodic_representative hp x] using hh
  choose b hbsg using hsg
  refine ⟨μ,H,N,b,hμE,hN,hp,haN,hbE,hbsg,?_⟩
  intro x hx y hy hxy hyE
  rw [←openRepresentative_congr_ae hFE] at hyE ⊢
  apply isMinimizerAt_convex_phase_monotone hV' hF hmF hμ hp haN
    isOpen_upperOctant convex_upperOctant (fun z hz i ↦ ⟨by linarith [(hz i).1],(hz i).2⟩) hx hy hyE
  intro z hz hbound
  simp only [PiLp.inner_apply,PiLp.sub_apply,RCLike.inner_apply,RCLike.conj_to_real]
  apply Finset.sum_nonneg
  intro i hi
  have hn := hbsg i z (hz i) (by rwa [hbd] at hbound)
  have hh := hxy i
  cases hbi : b i <;> simp only [hbi,Bool.false_eq_true,ite_false,ite_true] at hn hh
  · exact mul_nonneg_of_nonpos_of_nonpos (sub_nonpos.mpr hh) hn.le
  · exact mul_nonneg (sub_nonneg.mpr hh) hn.le

end CubicTorus

end
end

section

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

lemma smooth_periodic_centered_primitive {f : ℝ → ℝ}
    (hf : ContDiff ℝ (⊤ : ℕ∞) f) (hp : Function.Periodic f 1) :
    ∃ ψ : ℝ → ℝ,ContDiff ℝ (⊤ : ℕ∞) ψ ∧ Function.Periodic ψ 1 ∧
      ∀ t,deriv ψ t=f t-∫ u in (0 : ℝ)..1,f u := by
  let c : ℝ := ∫ u in (0 : ℝ)..1,f u
  let g : ℝ → ℝ := fun t ↦ f t-c
  have hg : ContDiff ℝ (⊤ : ℕ∞) g := hf.sub contDiff_const
  have hgp : Function.Periodic g 1 := fun t ↦ by simp [g,hp t]
  let ψ : ℝ → ℝ := fun t ↦ ∫ u in (0 : ℝ)..t,g u
  have hd (t : ℝ) : HasDerivAt ψ (g t) t :=
    intervalIntegral.integral_hasDerivAt_right (hg.continuous.intervalIntegrable _ _)
      hg.continuous.aestronglyMeasurable.stronglyMeasurableAtFilter hg.continuous.continuousAt
  have hψ : ContDiff ℝ (⊤ : ℕ∞) ψ := by
    apply contDiff_infty_iff_deriv.mpr
    exact ⟨fun t ↦ (hd t).differentiableAt,(funext fun t ↦ (hd t).deriv) ▸ hg⟩
  have hz : (∫ u in (0 : ℝ)..1,g u)=0 := by
    rw [show g=(fun t ↦ f t-c) from rfl,
      intervalIntegral.integral_sub (hf.continuous.intervalIntegrable _ _)
        intervalIntegrable_const,intervalIntegral.integral_const]
    simp [c]
  refine ⟨ψ,hψ,?_,fun t ↦ (hd t).deriv⟩
  intro t
  change (∫ u in (0 : ℝ)..t+1,g u)=∫ u in (0 : ℝ)..t,g u
  rw [hgp.intervalIntegral_add_eq_add 0 t (fun _ _ ↦ hg.continuous.intervalIntegrable _ _)]
  simp only [zero_add,hz,add_zero]

lemma axial_scalar_periodic {f : ℝ → ℝ} (hp : Function.Periodic f 1) (i : Fin 3) :
    ∀ (m : Fin 3 → ℤ) (x : Cover),f ((x+latticeVector m) i)=f (x i) := by
  intro m x
  simpa only [PiLp.add_apply,latticeVector,WithLp.ofLp_toLp,mul_one] using hp.int_mul (m i) (x i)

lemma axial_scalar_fderiv {f : ℝ → ℝ} (hf : Differentiable ℝ f) (i : Fin 3) (x v : Cover) :
    fderiv ℝ (fun y : Cover ↦ f (y i)) x v=deriv f (x i)*v i := by
  have hh := (hf (x i)).hasDerivAt.comp_hasFDerivAt x (EuclideanSpace.proj i : Cover →L[ℝ] ℝ).hasFDerivAt
  change HasFDerivAt (fun y : Cover ↦ f (y i)) _ x at hh
  rw [hh.fderiv]
  rfl

lemma axial_field_tangentialDivergence {f : ℝ → ℝ} (hf : Differentiable ℝ f)
    (i : Fin 3) (x ν : Cover) :
    tangentialDivergence (fun y : Cover ↦ f (y i) • EuclideanSpace.single i 1) x ν=
      deriv f (x i)*(1-(ν i)^2) := by
  have hd : DifferentiableAt ℝ (fun y : Cover ↦ f (y i)) x :=
    hf.differentiableAt.comp x (EuclideanSpace.proj i : Cover →L[ℝ] ℝ).differentiableAt
  rw [tangentialDivergence_smul_const hd,axial_scalar_fderiv hf]
  simp [tangentPart,EuclideanSpace.inner_single_right,pow_two]

lemma axial_field_divergence {f : ℝ → ℝ} (hf : Differentiable ℝ f)
    (i : Fin 3) (x : Cover) :
    divergence (fun y : Cover ↦ f (y i) • EuclideanSpace.single i 1) x=deriv f (x i) := by
  have hd : DifferentiableAt ℝ (fun y : Cover ↦ f (y i)) x :=
    hf.differentiableAt.comp x (EuclideanSpace.proj i : Cover →L[ℝ] ℝ).differentiableAt
  rw [divergence_smul_const hd,axial_scalar_fderiv hf]
  simp

theorem sibling_axial_flux_derivative {E : Set Torus} {μ : FiniteMeasure NormalBundle} {H : ℝ}
    (hH : ∀ D : Periodic.Variation,Periodic.normalFirstVariation μ D=
      H*directionalFlux E D.coordinate D.function)
    (i : Fin 3) {ψ : ℝ → ℝ} (hψ : ContDiff ℝ (⊤ : ℕ∞) ψ)
    (hp : Function.Periodic ψ 1) :
    (∫ z,deriv ψ ((z.1 : Cover) i)*(1-((z.2 : Cover) i)^2) ∂(μ : Measure NormalBundle))=
      H*∫ x in fundamentalCube∩quotientMap ⁻¹' E,deriv ψ (x i) := by
  have hfield : ContDiff ℝ (⊤ : ℕ∞)
      (fun x : Cover ↦ ψ (x i) • (EuclideanSpace.single i 1 : Cover)) :=
    (hψ.comp (EuclideanSpace.proj i : Cover →L[ℝ] ℝ).contDiff).smul contDiff_const
  have hh := Periodic.tangent_firstVariation_of_coordinate hH hfield (fun m x ↦ by
    rw [axial_scalar_periodic hp i m x])
  simpa only [axial_field_tangentialDivergence (hψ.differentiable (by simp)),
    axial_field_divergence (hψ.differentiable (by simp))] using hh

end CubicTorus

end
end

section

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

def axialTransverseMass (μ : FiniteMeasure NormalBundle) (i : Fin 3) : ℝ :=
  ∫ z,1-((z.2 : Cover) i)^2 ∂(μ : Measure NormalBundle)

lemma normal_component_continuous (i : Fin 3) :
    Continuous (fun z : NormalBundle ↦ (z.2 : Cover) i) :=
  (EuclideanSpace.proj i : Cover →L[ℝ] ℝ).continuous.comp normalEmbedding_continuous.snd

lemma normal_axial_integrable (μ : FiniteMeasure NormalBundle) (i : Fin 3)
    {f : ℝ → ℝ} (hf : Continuous f) :
    Integrable (fun z : NormalBundle ↦ f ((z.1 : Cover) i)*(1-((z.2 : Cover) i)^2))
      (μ : Measure NormalBundle) :=
  ((hf.comp ((EuclideanSpace.proj i : Cover →L[ℝ] ℝ).continuous.comp
    normalEmbedding_continuous.fst)).mul
      (continuous_const.sub ((normal_component_continuous i).pow 2))).integrable_of_hasCompactSupport
    (HasCompactSupport.of_compactSpace _)

lemma normal_transverse_integrable (μ : FiniteMeasure NormalBundle) (i : Fin 3) :
    Integrable (fun z : NormalBundle ↦ 1-((z.2 : Cover) i)^2) (μ : Measure NormalBundle) := by
  simpa only [one_mul] using normal_axial_integrable μ i (f := fun _ ↦ (1 : ℝ)) continuous_const

theorem axial_flux_marginal {E : Set Torus} {μ : FiniteMeasure NormalBundle} {H : ℝ}
    (hH : ∀ D : Periodic.Variation,Periodic.normalFirstVariation μ D=
      H*directionalFlux E D.coordinate D.function)
    (i : Fin 3) {f : ℝ → ℝ} (hf : ContDiff ℝ (⊤ : ℕ∞) f)
    (hp : Function.Periodic f 1) :
    (∫ z,f ((z.1 : Cover) i)*(1-((z.2 : Cover) i)^2) ∂(μ : Measure NormalBundle))-
      H*(∫ x in fundamentalCube∩quotientMap ⁻¹' E,f (x i))=
      (axialTransverseMass μ i-H*volume.real (fundamentalCube∩quotientMap ⁻¹' E))*
        ∫ t in (0 : ℝ)..1,f t := by
  obtain ⟨ψ,hψ,hψp,hd⟩ := smooth_periodic_centered_primitive hf hp
  have hh := sibling_axial_flux_derivative hH i hψ hψp
  simp_rw [hd,sub_mul] at hh
  have hiV : IntegrableOn (fun x : Cover ↦ f (x i))
      (fundamentalCube∩quotientMap ⁻¹' E) :=
    (integrableOn_fundamentalCube_of_continuous
      (hf.continuous.comp (EuclideanSpace.proj i : Cover →L[ℝ] ℝ).continuous)).mono_set inter_subset_left
  rw [integral_sub (normal_axial_integrable μ i hf.continuous)
      ((normal_transverse_integrable μ i).const_mul _),integral_const_mul,
    integral_sub hiV (integrable_const _),integral_const] at hh
  simp only [Measure.real_def,Measure.restrict_apply_univ,smul_eq_mul] at hh
  change _-_ = H*(_-volume.real (fundamentalCube∩quotientMap ⁻¹' E)*_) at hh
  unfold axialTransverseMass
  nlinarith [hh]

theorem isMinimizerAt_axial_flux {V : ℝ} (hV : V∈Ioo 0 1)
    {E : Set Torus} (hmin : IsMinimizerAt V E) :
    ∃ (μ : FiniteMeasure NormalBundle) (H : ℝ),IsNormalMeasure E μ ∧
      ∀ (i : Fin 3) (f : ℝ → ℝ),ContDiff ℝ (⊤ : ℕ∞) f → Function.Periodic f 1 →
      (∫ z,f ((z.1 : Cover) i)*(1-((z.2 : Cover) i)^2) ∂(μ : Measure NormalBundle))-
        H*(∫ x in fundamentalCube∩quotientMap ⁻¹' E,f (x i))=
        (axialTransverseMass μ i-H*V)*(∫ t in (0 : ℝ)..1,f t) := by
  let F := toMeasurable torusVolume E
  have hF : MeasurableSet F := measurableSet_toMeasurable _ _
  have hFE : F=ᵐ[torusVolume]E := hmin.1.1.toMeasurable_ae_eq
  have hmF := (isMinimizerAt_congr_ae hFE).mpr hmin
  obtain ⟨μ,H,hμ,hCMC,hs⟩ := Periodic.isMinimizerAt_boundary_stability hV hF hmF
  refine ⟨μ,H,hμ.congr_ae hFE,?_⟩
  intro i f hf hp
  have hh := axial_flux_marginal (Periodic.coordinateCMC_of_global hμ hCMC) i hf hp
  rw [setIntegral_congr_set (liftSet_congr_ae hFE)] at hh
  have hvol : volume.real (fundamentalCube ∩ quotientMap ⁻¹' F)=V := by
    rw [←realVolume_lift hF,Measure.real,hmF.2.1,ENNReal.toReal_ofReal hV.1.le]
  simpa only [hvol] using hh

end CubicTorus

end
end

section

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

theorem isMinimizerAt_stationary_tubular_normal {V : ℝ} (hV : V∈Ioo 0 1)
    {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E)
    {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) {H : ℝ}
    (hCMC : ∀ F : Cover → Cover,ContDiff ℝ (⊤ : ℕ∞) F →
      (∀ m x,F (x+latticeVector m)=F x) →
      (∫ z,tangentialDivergence F z.1 z.2 ∂(μ : Measure NormalBundle))=
        H*(∫ z,⟪(z.2 : Cover),F z.1⟫ ∂(μ : Measure NormalBundle))) :
    ∃ N : Cover → Cover,ContDiff ℝ (⊤ : ℕ∞) N ∧
      (∀ m x,N (x+latticeVector m)=N x) ∧
      (∀ᵐ z ∂(μ : Measure NormalBundle),N z.1=(z.2 : Cover)) ∧
      ∀ x : Cover,quotientMap x∈frontier (openRepresentative E) →
        (∀ᶠ y in 𝓝 x,‖N y‖=1) ∧ divergence N x=H := by
  obtain ⟨N,hN,hp,hn⟩ := isMinimizerAt_global_normal hV hE hmin hμ
  have hH := weakCMC_normal_extension hCMC hN hp hn
  have hpoint (x : Cover) (hx : quotientMap x∈frontier (openRepresentative E)) :
      ‖N x‖=1 ∧ divergence N x=H := by
    constructor
    · apply isMinimizerAt_periodic_ae_eq_boundary hV hE hmin hμ hN.continuous.norm
        continuous_const (fun m y ↦ by rw [hp]) (fun _ _ ↦ rfl) _ x hx
      filter_upwards [hn] with z hz
      rw [hz.1,z.2.property]
    · exact isMinimizerAt_periodic_ae_eq_boundary hV hE hmin hμ (continuous_divergence hN)
        continuous_const (divergence_periodic hp) (fun _ _ ↦ rfl) hH x hx
  have hR := regularizedNormal_contDiff hN
  have hrp : ∀ m x,regularizedNormal N (x+latticeVector m)=regularizedNormal N x := by
    intro m x
    simp only [regularizedNormal,hp]
  have he : ∀ᵐ z ∂(μ : Measure NormalBundle),regularizedNormal N=ᶠ[𝓝 (z.1 : Cover)]N := by
    filter_upwards [hn] with z hz
    exact regularizedNormal_eventuallyEq hz.2
  refine ⟨regularizedNormal N,hR,hrp,?_,?_⟩
  · filter_upwards [hn,he] with z hz hze
    exact hze.eq_of_nhds.trans hz.1
  · intro x hx
    refine ⟨regularizedNormal_unit_near hN.continuous (by rw [(hpoint x hx).1]; norm_num),?_⟩
    apply isMinimizerAt_periodic_ae_eq_boundary hV hE hmin hμ
      (continuous_divergence hR) (continuous_divergence hN)
      (divergence_periodic hrp) (divergence_periodic hp) _ x hx |>.trans (hpoint x hx).2
    filter_upwards [he] with z hz
    simp only [divergence_eq_coverTrace,hz.fderiv_eq]

end CubicTorus

end
end

section

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

lemma normalSphere_sum_sq (ν : NormalSphere) : (∑ i : Fin 3,((ν : Cover) i)^2)=1 := by
  have hh := real_inner_self_eq_norm_sq (ν : Cover)
  rw [ν.property,one_pow] at hh
  simpa only [PiLp.inner_apply,RCLike.inner_apply,RCLike.conj_to_real,←pow_two] using hh

lemma normalSphere_coordinate_sq_le (ν : NormalSphere) (i : Fin 3) : ((ν : Cover) i)^2≤1 := by
  exact (Finset.single_le_sum (fun j (_ : j∈(Finset.univ : Finset (Fin 3))) ↦ sq_nonneg ((ν : Cover) j))
    (Finset.mem_univ i)).trans_eq (normalSphere_sum_sq ν)

lemma axialTransverseMass_nonneg (μ : FiniteMeasure NormalBundle) (i : Fin 3) :
    0≤axialTransverseMass μ i :=
  integral_nonneg fun z ↦ sub_nonneg.mpr (normalSphere_coordinate_sq_le z.2 i)

lemma axialTransverseMass_sum (μ : FiniteMeasure NormalBundle) :
    (∑ i : Fin 3,axialTransverseMass μ i)=2*(μ.mass : ℝ) := by
  unfold axialTransverseMass
  rw [←integral_finsetSum _ (fun i _ ↦ normal_transverse_integrable μ i)]
  have hh (z : NormalBundle) : (∑ i : Fin 3,(1-((z.2 : Cover) i)^2))=(2 : ℝ) := by
    rw [Finset.sum_sub_distrib,normalSphere_sum_sq]
    norm_num
  simp_rw [hh]
  simp only [integral_const,smul_eq_mul,Measure.real_def,
    ←FiniteMeasure.ennreal_mass,ENNReal.coe_toReal]
  ring

lemma axialTransverseMass_defect (μ : FiniteMeasure NormalBundle) (i : Fin 3) :
    axialTransverseMass μ i=(μ.mass : ℝ)-∫ z,((z.2 : Cover) i)^2 ∂(μ : Measure NormalBundle) := by
  unfold axialTransverseMass
  have hi : Integrable (fun z : NormalBundle ↦ ((z.2 : Cover) i)^2) (μ : Measure NormalBundle) :=
    ((normal_component_continuous i).pow 2).integrable_of_hasCompactSupport
      (HasCompactSupport.of_compactSpace _)
  rw [integral_sub (integrable_const _) hi,normalMeasure_integral_one]

theorem isMinimizerAt_nonstandard_axial_mass_lt {V : ℝ} (hV : V∈Ioc 0 (1/2))
    {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E)
    (hc : IsPreconnected (frontier (openRepresentative E))) (hstd : ¬StandardRegionAt V E)
    {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ)
    {N : Cover → Cover} (hN : ContDiff ℝ (⊤ : ℕ∞) N)
    (hp : ∀ m x,N (x+latticeVector m)=N x)
    (hae : ∀ᵐ z ∂(μ : Measure NormalBundle),N z.1=(z.2 : Cover))
    {H : ℝ} (hb : ∀ x : Cover,quotientMap x∈frontier (openRepresentative E) →
      (∀ᶠ y in 𝓝 x,‖N y‖=1) ∧ divergence N x=H) (i : Fin 3) :
    axialTransverseMass μ i<(μ.mass : ℝ) := by
  rw [axialTransverseMass_defect,sub_lt_self_iff]
  have hi : Integrable (fun z : NormalBundle ↦ ((z.2 : Cover) i)^2) (μ : Measure NormalBundle) :=
    ((normal_component_continuous i).pow 2).integrable_of_hasCompactSupport
      (HasCompactSupport.of_compactSpace _)
  have hznon : 0≤∫ z,((z.2 : Cover) i)^2 ∂(μ : Measure NormalBundle) :=
    integral_nonneg fun _ ↦ sq_nonneg _
  by_contra hpos
  have hz := (integral_eq_zero_iff_of_nonneg (fun z : NormalBundle ↦ sq_nonneg ((z.2 : Cover) i)) hi).mp
    (le_antisymm (le_of_not_gt hpos) hznon)
  have hn0 : ∀ᵐ z ∂(μ : Measure NormalBundle),N z.1 i=0 := by
    filter_upwards [hae,hz] with z he hz
    rw [he]
    exact sq_eq_zero_iff.mp hz
  have hb0 (x : Torus) (hx : x∈frontier (openRepresentative E)) : N (representative x) i=0 := by
    apply isMinimizerAt_periodic_ae_eq_boundary ⟨hV.1,by linarith [hV.2]⟩ hE hmin hμ
      (((EuclideanSpace.proj i : Cover →L[ℝ] ℝ).continuous).comp hN.continuous)
      continuous_const (fun m y ↦ by change N (y+latticeVector m) i=N y i; rw [hp]) (fun _ _ ↦ rfl) hn0 (representative x)
    simpa only [quotientMap_representative] using hx
  obtain ⟨hlo,hhi,hcong⟩ := isMinimizerAt_zero_axis_standard hV hmin hc hμ hN hp hae hb i hb0
  apply hstd
  unfold StandardRegionAt SmallStandardRegion
  rw [ite_eq_left hV.2]
  exact Or.inr (Or.inl ⟨hlo,hhi,hcong⟩)

end CubicTorus

end
end

section

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

def circleMollifier (n : ℕ) : ContDiffBump (0 : ℝ) where
  rIn := 1/((n : ℝ)+1)
  rOut := 2/((n : ℝ)+1)
  rIn_pos := by positivity
  rIn_lt_rOut := by apply div_lt_div_of_pos_right (by norm_num); positivity

lemma circleMollifier_tendsto : Tendsto (fun n ↦ (circleMollifier n).rOut) atTop (𝓝 0) := by
  simpa only [circleMollifier,mul_one,mul_div,mul_zero] using
    (tendsto_const_nhds (x := (2 : ℝ))).mul
      (tendsto_one_div_add_atTop_nhds_zero_nat (𝕜 := ℝ))

def circleSmoothApprox (f : ℝ → ℝ) (n : ℕ) : ℝ → ℝ :=
  (circleMollifier n).normed volume ⋆ f

lemma circleSmoothApprox_contDiff {f : ℝ → ℝ} (hf : Continuous f) (n : ℕ) :
    ContDiff ℝ (⊤ : ℕ∞) (circleSmoothApprox f n) :=
  (circleMollifier n).hasCompactSupport_normed.contDiff_convolution_left
    (ContinuousLinearMap.lsmul ℝ ℝ) (circleMollifier n).contDiff_normed hf.locallyIntegrable

lemma circleSmoothApprox_periodic {f : ℝ → ℝ} (hp : Function.Periodic f 1) (n : ℕ) :
    Function.Periodic (circleSmoothApprox f n) 1 := by
  intro x
  simp only [circleSmoothApprox,convolution_def,ContinuousLinearMap.lsmul_apply]
  apply integral_congr_ae
  filter_upwards [] with y
  rw [show x+1-y=(x-y)+1 by ring,hp]

lemma circleSmoothApprox_tendsto {f : ℝ → ℝ} (hf : Continuous f) (x : ℝ) :
    Tendsto (fun n ↦ circleSmoothApprox f n x) atTop (𝓝 (f x)) :=
  ContDiffBump.convolution_tendsto_right_of_continuous circleMollifier_tendsto hf x

lemma circleSmoothApprox_bound {f : ℝ → ℝ} {C : ℝ} (hb : ∀ x,‖f x‖≤C)
    (n : ℕ) (x : ℝ) : ‖circleSmoothApprox f n x‖≤C := by
  rw [circleSmoothApprox,convolution_def]
  calc
    _ ≤ ∫ y : ℝ,(circleMollifier n).normed volume y*C := by
      apply norm_integral_le_of_norm_le ((circleMollifier n).integrable_normed.mul_const C)
      filter_upwards [] with y
      rw [ContinuousLinearMap.lsmul_apply,norm_smul,Real.norm_eq_abs,
        abs_of_nonneg ((circleMollifier n).nonneg_normed y)]
      exact mul_le_mul_of_nonneg_left (hb (x-y)) ((circleMollifier n).nonneg_normed y)
    _ = C := by rw [integral_mul_const,(circleMollifier n).integral_normed,one_mul]

lemma circleSmoothApprox_integral_tendsto {α : Type*} [MeasurableSpace α]
    {η : Measure α} {g w : α → ℝ} (hg : Measurable g) (hw : Integrable w η)
    {f : ℝ → ℝ} (hf : Continuous f) (hp : Function.Periodic f 1) :
    Tendsto (fun n ↦ ∫ x,circleSmoothApprox f n (g x)*w x ∂η) atTop
      (𝓝 (∫ x,f (g x)*w x ∂η)) := by
  obtain ⟨C,hC⟩ := (hp.isBounded_of_continuous (by norm_num) hf).exists_norm_le
  have hbound (t : ℝ) : ‖f t‖≤C := hC _ ⟨t,rfl⟩
  apply tendsto_integral_of_dominated_convergence (fun x ↦ C*‖w x‖)
  · intro n
    exact (((circleSmoothApprox_contDiff hf n).continuous.measurable.comp hg).aestronglyMeasurable).mul
      hw.aestronglyMeasurable
  · exact hw.norm.const_mul C
  · intro n
    filter_upwards [] with x
    rw [norm_mul]
    exact mul_le_mul_of_nonneg_right (circleSmoothApprox_bound hbound n (g x)) (norm_nonneg _)
  · filter_upwards [] with x
    exact (circleSmoothApprox_tendsto hf (g x)).mul tendsto_const_nhds

lemma circleSmoothApprox_integral_tendsto_finite {α : Type*} [MeasurableSpace α]
    {η : Measure α} [IsFiniteMeasure η] {g : α → ℝ} (hg : Measurable g)
    {f : ℝ → ℝ} (hf : Continuous f) (hp : Function.Periodic f 1) :
    Tendsto (fun n ↦ ∫ x,circleSmoothApprox f n (g x) ∂η) atTop
      (𝓝 (∫ x,f (g x) ∂η)) := by
  simpa only [mul_one] using circleSmoothApprox_integral_tendsto hg
    (integrable_const (1 : ℝ) (μ := η)) hf hp

theorem axial_flux_marginal_continuous {E : Set Torus} {μ : FiniteMeasure NormalBundle} {H : ℝ}
    (hH : ∀ D : Periodic.Variation,Periodic.normalFirstVariation μ D=
      H*directionalFlux E D.coordinate D.function)
    (i : Fin 3) {f : ℝ → ℝ} (hf : Continuous f) (hp : Function.Periodic f 1) :
    (∫ z,f ((z.1 : Cover) i)*(1-((z.2 : Cover) i)^2) ∂(μ : Measure NormalBundle))-
      H*(∫ x in fundamentalCube∩quotientMap ⁻¹' E,f (x i))=
      (axialTransverseMass μ i-H*volume.real (fundamentalCube∩quotientMap ⁻¹' E))*
        ∫ t in (0 : ℝ)..1,f t := by
  let A := fundamentalCube∩quotientMap ⁻¹' E
  have hA : volume A≠⊤ := ne_top_of_le_ne_top (by rw [volume_fundamentalCube]; exact ENNReal.one_ne_top)
    (measure_mono inter_subset_left)
  let : IsFiniteMeasure (volume.restrict A) := ⟨by simpa only [Measure.restrict_apply_univ] using hA.lt_top⟩
  have hs := circleSmoothApprox_integral_tendsto
    (((EuclideanSpace.proj i : Cover →L[ℝ] ℝ).continuous.comp normalEmbedding_continuous.fst).measurable)
    (normal_transverse_integrable μ i) hf hp
  have hv := circleSmoothApprox_integral_tendsto_finite (η := volume.restrict A)
    (EuclideanSpace.proj i : Cover →L[ℝ] ℝ).measurable hf hp
  have ht := circleSmoothApprox_integral_tendsto_finite (η := volume.restrict (Ioc (0 : ℝ) 1))
    measurable_id hf hp
  have ht' : Tendsto (fun n ↦ ∫ t in (0 : ℝ)..1,circleSmoothApprox f n t) atTop
      (𝓝 (∫ t in (0 : ℝ)..1,f t)) := by
    simpa only [intervalIntegral.integral_of_le (by norm_num : (0 : ℝ)≤1),id_eq] using ht
  have hleft := hs.sub (hv.const_mul H)
  have hright := ht'.const_mul (axialTransverseMass μ i-H*volume.real A)
  apply tendsto_nhds_unique hleft
  apply hright.congr'
  filter_upwards [] with n
  exact (axial_flux_marginal hH i (circleSmoothApprox_contDiff hf n)
    (circleSmoothApprox_periodic hp n)).symm

end CubicTorus

end
end

section

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

abbrev AxisCircle := AddCircle (1 : ℝ)

def axialSurfaceMarginal (μ : FiniteMeasure NormalBundle) (i : Fin 3) : FiniteMeasure AxisCircle := by
  let η := (μ : Measure NormalBundle).withDensity (fun z ↦ ENNReal.ofReal (1-((z.2 : Cover) i)^2))
  haveI : IsFiniteMeasure η := isFiniteMeasure_withDensity_ofReal
    (normal_transverse_integrable μ i).hasFiniteIntegral
  exact ⟨Measure.map (fun z : NormalBundle ↦ (((z.1 : Cover) i) : AxisCircle)) η,inferInstance⟩

def axialVolumeMarginal (E : Set Torus) (i : Fin 3) : FiniteMeasure AxisCircle := by
  let η := volume.restrict (fundamentalCube∩quotientMap ⁻¹' E)
  haveI : IsFiniteMeasure η := ⟨by
    rw [Measure.restrict_apply_univ]
    exact (measure_mono inter_subset_left).trans_lt (by rw [volume_fundamentalCube]; exact ENNReal.one_lt_top)⟩
  exact ⟨Measure.map (fun x : Cover ↦ (x i : AxisCircle)) η,inferInstance⟩

end CubicTorus
end
end
end

end OAI