lean/OAI/Geometry/CubicTorus/Profiles/NormalTransverseLength.lean

import Mathlib
import OAI.Geometry.CubicTorus.Reflection.ActualAxialFlux

namespace OAI

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

theorem isMinimizerAt_nonstandard_missing_neighbor_flux {V : ℝ} (hV : V∈Ioo 0 1)
    {E : Set Torus} (hmin : IsMinimizerAt V E) (hstd : ¬StandardRegionAt V E)
    (hR : ∀ i : Fin 3,E=ᵐ[torusVolume]((axisReflection i).torus ⁻¹' E))
    (b : Fin 3 → Bool)
    (hd : ∀ x∈upperOctant,∀ y∈upperOctant,OrientedCoordinateLE b x y →
      quotientMap y∈openRepresentative E →quotientMap x∈openRepresentative 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))) (i : Fin 3)
    (hv : quotientMap (orientedUpperVertex b (fun j ↦ if j=i then true else false))∉openRepresentative E) :
    0<H ∧ V≤1/2 ∧ axialTransverseMass μ i=H*V := by
  have hc : IsPreconnected (frontier (openRepresentative E)) :=
    (Periodic.isMinimizerAt_connected_or_standard_slab hV hmin).resolve_right (fun h ↦ hstd h.2.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 ho := openRepresentative_congr_ae hFE
  have hcF : IsPreconnected (frontier (openRepresentative F)) := by rwa [ho]
  have hRF (j : Fin 3) : F=ᵐ[torusVolume]((axisReflection j).torus ⁻¹' F) :=
    hFE.trans ((hR j).trans ((axisReflection j).measurePreserving.quasiMeasurePreserving.preimage_ae_eq hFE.symm))
  have hdF : ∀ x∈upperOctant,∀ y∈upperOctant,OrientedCoordinateLE b x y →
      quotientMap y∈openRepresentative F →quotientMap x∈openRepresentative F := by rwa [ho]
  have hvF : quotientMap (orientedUpperVertex b (fun j ↦ if j=i then true else false))∉openRepresentative F := by rwa [ho]
  have hμF := hμ.congr_ae hFE.symm
  have hflux := isMinimizerAt_missing_neighbor_flux_unrestricted hV hF hmF hRF b hdF hμF
    (Periodic.coordinateCMC_of_global hμF hCMC) i hvF
  obtain ⟨N,hN,hp,hae,_⟩ := isMinimizerAt_stationary_tubular_normal hV hF hmF hμF hCMC
  have hpos := isMinimizerAt_connected_transverse_mass_pos hV hF hmF hcF hμF hN hp hae i
  have hHpos : 0<H := by
    rw [hflux] at hpos
    exact (mul_pos_iff_of_pos_right hV.1).mp hpos
  exact ⟨hHpos,isMinimizerAt_missing_neighbor_volume_le_half hV hF hmF hcF hRF b hdF i hvF,hflux⟩

end CubicTorus

end
end

section

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

lemma isMinimizerAt_missing_neighbor_top_empty {V : ℝ} (hV : V∈Ioo 0 1)
    {E : Set Torus} (hmin : IsMinimizerAt V E)
    (hR : ∀ i : Fin 3,E=ᵐ[torusVolume]((axisReflection i).torus ⁻¹' E))
    (b : Fin 3 →Bool)
    (hd : ∀ x∈upperOctant,∀ y∈upperOctant,OrientedCoordinateLE b x y →
      quotientMap y∈openRepresentative E →quotientMap x∈openRepresentative E)
    (i : Fin 3)
    (hv : quotientMap (orientedUpperVertex b (fun j ↦ if j=i then true else false))∉openRepresentative E) :
    axialSlice (openRepresentative E) i (octantHeight b i 1 : AxisCircle)=∅ := by
  apply eq_empty_iff_forall_notMem.mpr
  intro y hy
  exact isMinimizerAt_missing_neighbor_gap hV hmin hR b hd i hv
    ((torusAxialSplit i).symm ((octantHeight b i 1 : AxisCircle),y)) (subset_closure hy)
    (torusAxialSplit_symm_same _ _ _)

theorem isMinimizerAt_missing_neighbor_projection {V : ℝ} (hV : V∈Ioo 0 1)
    {E : Set Torus} (hE : MeasurableSet E) (hmin : IsMinimizerAt V E)
    (hR : ∀ i : Fin 3,E=ᵐ[torusVolume]((axisReflection i).torus ⁻¹' E))
    (b : Fin 3 →Bool)
    (hd : ∀ x∈upperOctant,∀ y∈upperOctant,OrientedCoordinateLE b x y →
      quotientMap y∈openRepresentative E →quotientMap x∈openRepresentative E)
    {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) {H : ℝ}
    (hH : ∀ D : Periodic.Variation,Periodic.normalFirstVariation μ D=
      H*directionalFlux E D.coordinate D.function)
    (i : Fin 3) (ha : (axialAreaMarginal μ i : Measure AxisCircle)≪volume)
    (hv : quotientMap (orientedUpperVertex b (fun j ↦ if j=i then true else false))∉openRepresentative E) :
    let s := volume.real (axialSlice (openRepresentative E) i (octantHeight b i 0 : AxisCircle))
    s^2 ≤ ((perimeter E).toReal/2)*((perimeter E).toReal/2-(H/2)*V) := by
  dsimp only
  let s := volume.real (axialSlice (openRepresentative E) i (octantHeight b i 0 : AxisCircle))
  have hz : (axialSliceVolume (openRepresentative E) i (octantHeight b i 1 : AxisCircle)).toReal=0 := by
    rw [axialSliceVolume,isMinimizerAt_missing_neighbor_top_empty hV hmin hR b hd i hv,measure_empty,ENNReal.toReal_zero]
  have hh := isMinimizerAt_actual_projection_bound hV hE hmin hμ i ha
  have hdiff : |(axialSliceVolume (openRepresentative E) i ((1/2 : ℝ) : AxisCircle)).toReal-
      (axialSliceVolume (openRepresentative E) i 0).toReal|=s := by
    dsimp only [s,Measure.real,axialSliceVolume] at hz ⊢
    unfold octantHeight at hz ⊢
    cases hb : b i <;> simp only [hb,Bool.false_eq_true,ite_false,ite_true] at hz ⊢
    · norm_num [AddCircle.coe_period] at hz ⊢
      rw [hz,zero_sub,abs_neg,abs_of_nonneg ENNReal.toReal_nonneg]
    · norm_num [AddCircle.coe_period] at hz ⊢
      rw [hz,sub_zero,abs_of_nonneg ENNReal.toReal_nonneg]
  rw [hdiff] at hh
  have hr : 0 ≤ (μ.mass : ℝ)*((μ.mass : ℝ)-axialTransverseMass μ i) := by
    apply mul_nonneg (NNReal.coe_nonneg _)
    rw [axialTransverseMass_defect]
    simp only [sub_sub_cancel]
    exact integral_nonneg (fun _ ↦ sq_nonneg _)
  have hs : 0 ≤ s := measureReal_nonneg
  have hh2 := pow_le_pow_left₀ (by positivity : 0 ≤ 2*s) hh 2
  rw [Real.sq_sqrt hr,hμ.1,isMinimizerAt_missing_neighbor_flux_unrestricted hV hE hmin hR b hd hμ hH i hv] at hh2
  change s^2 ≤ _
  nlinarith

end CubicTorus

end
end

section

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

theorem isMinimizerAt_no_face_pattern {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)
    (hd : ∀ x∈upperOctant,∀ y∈upperOctant,OrientedCoordinateLE b x y →
      quotientMap y∈openRepresentative E →quotientMap x∈openRepresentative E)
    (i : Fin 3)
    (hface : quotientMap (orientedUpperVertex b (fun j ↦ if j=i then false else true))∈openRepresentative E) :
    quotientMap (orientedUpperVertex b (fun j ↦ if j=i then true else false))∈openRepresentative E := by
  classical
  by_contra haxis
  obtain ⟨z,hzb,hseam⟩ := connected_reflected_boundary_meets_axial_seam hc
    (isMinimizerAt_frontier_nonempty_null hV hmin) (reflection_invariant_frontier hmin.1.1 hR) i
  let x := upperFold z
  have hx := upperFold_mem z
  have hxb : quotientMap x∈frontier (openRepresentative E) :=
    (upperFold_phase (reflection_invariant_frontier hmin.1.1 hR) z).mpr hzb
  let u := orientedUpperVertex b (fun j ↦ if j=i then false else true)
  let v := orientedUpperVertex b (fun j ↦ if j=i then true else false)
  have hmincase : x i=(if b i then (1/2 : ℝ) else 1) → False := by
    intro hxi
    have hxu : OrientedCoordinateLE b x u := by
      intro j
      by_cases hji : j=i
      · subst j
        dsimp only [u,orientedUpperVertex,upperVertex]
        simp only [ite_true,Bool.not_false]
        rw [hxi]
        cases b i <;> simp
      · have hh := orientedUpperVertex_max b hx j
        have hu : u j=orientedUpperVertex b (fun _ ↦ true) j := by
          dsimp [u,orientedUpperVertex,upperVertex]; simp [hji]
        change (if b j then x j≤u j else u j≤x j)
        rw [hu]
        exact hh
    have hxo := isMinimizerAt_closed_octant_order hV hmin hR hd hx (upperVertex_mem _) hxu hface
    rw [(isOpen_openRepresentative E).frontier_eq] at hxb
    exact hxb.2 hxo
  have hmaxcase : x i=(if b i then (1 : ℝ) else 1/2) → False := by
    intro hxi
    have hvx : OrientedCoordinateLE b v x := by
      intro j
      by_cases hji : j=i
      · subst j
        dsimp only [v,orientedUpperVertex,upperVertex]
        simp only [ite_true,Bool.not_true]
        rw [hxi]
        cases b i <;> simp
      · have hh := orientedUpperVertex_min b hx j
        have hv : v j=orientedUpperVertex b (fun _ ↦ false) j := by
          dsimp [v,orientedUpperVertex,upperVertex]; simp [hji]
        change (if b j then v j≤x j else x j≤v j)
        rw [hv]
        exact hh
    have hvcl := octant_downset_closure (isOpen_openRepresentative E)
      (reflection_invariant_openRepresentative hmin.1.1 hR) hd (upperVertex_mem _) hx hvx
      (frontier_subset_closure hxb)
    have hvb : quotientMap v∈frontier (openRepresentative E) := by
      rw [(isOpen_openRepresentative E).frontier_eq]
      exact ⟨hvcl,haxis⟩
    exact isMinimizerAt_common_fixed_not_boundary hV hmin hR _ (upperVertex_fixed _) hvb
  change x i=(1/2 : ℝ) ∨ x i=1 at hseam
  cases hb : b i <;> simp only [hb,Bool.false_eq_true,ite_false,ite_true] at hmincase hmaxcase
  · exact hseam.elim hmaxcase hmincase
  · exact hseam.elim hmincase hmaxcase

end CubicTorus

end
end

section

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

def normalTransverseLength (i : Fin 3) (z : NormalBundle) : ℝ :=
  Real.sqrt (1-((z.2 : Cover) i)^2)

lemma normalTransverseLength_continuous (i : Fin 3) : Continuous (normalTransverseLength i) :=
  (continuous_const.sub ((normal_component_continuous i).pow 2)).sqrt

lemma normalTransverseLength_nonneg (i : Fin 3) (z : NormalBundle) :
    0≤normalTransverseLength i z := Real.sqrt_nonneg _

lemma normalTransverseLength_sq (i : Fin 3) (z : NormalBundle) :
    (normalTransverseLength i z)^2+((z.2 : Cover) i)^2=1 := by
  rw [normalTransverseLength,Real.sq_sqrt (sub_nonneg.mpr (normalSphere_coordinate_sq_le z.2 i))]
  ring

lemma normalTransverseLength_le_one (i : Fin 3) (z : NormalBundle) :
    normalTransverseLength i z≤1 := by
  have h := normalTransverseLength_sq i z
  nlinarith [sq_nonneg ((z.2 : Cover) i)]

def axialPerimeterMarginal (μ : FiniteMeasure NormalBundle) (i : Fin 3) : FiniteMeasure AxisCircle := by
  let η := (μ : Measure NormalBundle).withDensity (fun z ↦ ENNReal.ofReal (normalTransverseLength i z))
  have hi : Integrable (normalTransverseLength i) (μ : Measure NormalBundle) :=
    (normalTransverseLength_continuous i).integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _)
  haveI : IsFiniteMeasure η := isFiniteMeasure_withDensity_ofReal hi.hasFiniteIntegral
  exact ⟨Measure.map (fun z : NormalBundle ↦ (((z.1 : Cover) i) : AxisCircle)) η,inferInstance⟩

lemma axialPerimeterMarginal_absolutelyContinuous {μ : FiniteMeasure NormalBundle} (i : Fin 3)
    (ha : (axialAreaMarginal μ i : Measure AxisCircle)≪volume) :
    (axialPerimeterMarginal μ i : Measure AxisCircle)≪volume := by
  apply Measure.AbsolutelyContinuous.mk
  intro s hs hz
  have hh := ha hz
  change Measure.map _ _ s=0 at hh ⊢
  rw [Measure.map_apply (normal_axisCircle_continuous i).measurable hs] at hh ⊢
  exact withDensity_absolutelyContinuous _ _ hh

def axialPerimeterDensity (μ : FiniteMeasure NormalBundle) (i : Fin 3) (t : AxisCircle) : ℝ :=
  ((axialPerimeterMarginal μ i : Measure AxisCircle).rnDeriv volume t).toReal

lemma axialPerimeterDensity_nonneg (μ : FiniteMeasure NormalBundle) (i : Fin 3) (t : AxisCircle) :
    0≤axialPerimeterDensity μ i t := ENNReal.toReal_nonneg

lemma axialPerimeterDensity_integrable (μ : FiniteMeasure NormalBundle) (i : Fin 3) :
    Integrable (axialPerimeterDensity μ i) := Measure.integrable_toReal_rnDeriv

lemma axialPerimeterDensity_measurable (μ : FiniteMeasure NormalBundle) (i : Fin 3) :
    Measurable (axialPerimeterDensity μ i) := (Measure.measurable_rnDeriv _ _).ennreal_toReal

lemma axialPerimeterDensity_pairing_bounded {μ : FiniteMeasure NormalBundle} (i : Fin 3)
    (ha : (axialAreaMarginal μ i : Measure AxisCircle)≪volume)
    {f : AxisCircle → ℝ} (hf : Measurable f) (_hb : ∀ t,|f t|≤1) :
    (∫ t,axialPerimeterDensity μ i t*f t)=
      ∫ z,normalTransverseLength i z*f (((z.1 : Cover) i) : AxisCircle) ∂(μ : Measure NormalBundle) := by
  have hp := axialPerimeterMarginal_absolutelyContinuous i ha
  change (∫ t,((axialPerimeterMarginal μ i : Measure AxisCircle).rnDeriv volume t).toReal*f t)=_
  rw [integral_toReal_rnDeriv_mul hp]
  change (∫ t,f t ∂Measure.map _ _)=_
  rw [integral_map (normal_axisCircle_continuous i).measurable.aemeasurable hf.aestronglyMeasurable]
  rw [integral_withDensity_eq_integral_toReal_smul
    (normalTransverseLength_continuous i).measurable.ennreal_ofReal
    (ae_of_all _ fun _ ↦ ENNReal.ofReal_lt_top)]
  apply integral_congr_ae
  filter_upwards [] with z
  rw [ENNReal.toReal_ofReal (normalTransverseLength_nonneg i z),smul_eq_mul]

end CubicTorus

end
end

section

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

lemma bounded_real_locallyIntegrable {f : ℝ → ℝ} (hf : Measurable f)
    (hb : ∀ t,|f t|≤1) : LocallyIntegrable f volume := by
  apply (continuous_const : Continuous (fun _ : ℝ ↦ (1 : ℝ))).locallyIntegrable.mono hf.aestronglyMeasurable
  exact ae_of_all _ fun t ↦ by simpa only [Real.norm_eq_abs,abs_one] using hb t

lemma circleSmoothApprox_bounded_contDiff {f : ℝ → ℝ} (hf : Measurable f)
    (hb : ∀ t,|f t|≤1) (n : ℕ) : ContDiff ℝ (⊤ : ℕ∞) (circleSmoothApprox f n) :=
  (circleMollifier n).hasCompactSupport_normed.contDiff_convolution_left
    (ContinuousLinearMap.lsmul ℝ ℝ) (circleMollifier n).contDiff_normed
    (bounded_real_locallyIntegrable hf hb)

lemma circleSmoothApprox_nonneg {f : ℝ → ℝ} (hf : ∀ t,0≤f t) (n : ℕ) (t : ℝ) :
    0≤circleSmoothApprox f n t := by
  rw [circleSmoothApprox,convolution_def]
  exact integral_nonneg fun x ↦ mul_nonneg ((circleMollifier n).nonneg_normed x) (hf (t-x))

lemma circleSmoothApprox_bounded_ae_tendsto {f : ℝ → ℝ} (hf : Measurable f)
    (hb : ∀ t,|f t|≤1) :
    ∀ᵐ t : ℝ,Tendsto (fun n ↦ circleSmoothApprox f n t) atTop (𝓝 (f t)) := by
  apply ContDiffBump.ae_convolution_tendsto_right_of_locallyIntegrable
    circleMollifier_tendsto (K := 2) _ (bounded_real_locallyIntegrable hf hb)
  exact Eventually.of_forall fun n ↦ by dsimp [circleMollifier]; ring_nf; rfl

lemma circleSmoothApprox_lift_ae_tendsto {f : AxisCircle → ℝ} (hf : Measurable f)
    (hb : ∀ t,|f t|≤1) :
    let F : ℝ → ℝ := fun t ↦ f (t : AxisCircle)
    let hp : Function.Periodic F 1 := fun t ↦ by dsimp only [F]; rw [AddCircle.coe_add_period]
    ∀ᵐ t : AxisCircle,Tendsto (fun n ↦ (circleSmoothApprox_periodic hp n).lift t) atTop (𝓝 (f t)) := by
  intro F hp
  have hfm : Measurable F := hf.comp (AddCircle.continuous_mk' (1 : ℝ)).measurable
  have hh := ae_restrict_of_ae (s := Ioc (0 : ℝ) 1) (circleSmoothApprox_bounded_ae_tendsto hfm (fun t ↦ hb _))
  have hmp : MeasurePreserving (fun t : ℝ ↦ (t : AxisCircle)) (volume.restrict (Ioc 0 1)) volume := by
    simpa using AddCircle.measurePreserving_mk (1 : ℝ) 0
  rw [←hmp.map_eq]
  apply (ae_map_iff hmp.measurable.aemeasurable (measurableSet_tendsto_fun
    (fun n ↦ (continuous_periodic_lift (circleSmoothApprox_periodic hp n)
      (circleSmoothApprox_bounded_contDiff hfm (fun t ↦ hb _) n).continuous).measurable) hf)).mpr
  simpa only [Function.Periodic.lift_coe] using hh

theorem integrable_circle_nonneg_of_smooth_pairing {h : AxisCircle → ℝ} (hi : Integrable h)
    (hw : ∀ (ψ : ℝ → ℝ),ContDiff ℝ (⊤ : ℕ∞) ψ → ∀ hp : Function.Periodic ψ 1,
      (∀ t,0≤ψ t) → 0≤∫ t,h t*hp.lift t) : 0≤ᵐ[volume] h := by
  apply ae_nonneg_of_forall_setIntegral_nonneg hi
  intro s hs _
  let f : AxisCircle → ℝ := s.indicator (fun _ ↦ (1 : ℝ))
  let F : ℝ → ℝ := fun t ↦ f (t : AxisCircle)
  have hf : Measurable f := measurable_const.indicator hs
  have hb (t : AxisCircle) : |f t|≤1 := by
    by_cases ht : t∈s <;> simp [f,ht]
  have hn (t : ℝ) : 0≤F t := by apply indicator_nonneg; intro _ _; norm_num
  have hp : Function.Periodic F 1 := fun t ↦ by dsimp only [F]; rw [AddCircle.coe_add_period]
  have hc n := circleSmoothApprox_bounded_contDiff (hf.comp (AddCircle.continuous_mk' (1 : ℝ)).measurable)
    (fun t ↦ hb _) n
  have hl : Tendsto (fun n ↦ ∫ t,h t*(circleSmoothApprox_periodic hp n).lift t) atTop
      (𝓝 (∫ t,h t*f t)) := by
    apply tendsto_integral_of_dominated_convergence (fun t ↦ ‖h t‖)
    · intro n
      exact hi.aestronglyMeasurable.mul (continuous_periodic_lift (circleSmoothApprox_periodic hp n)
        (hc n).continuous).aestronglyMeasurable
    · exact hi.norm
    · intro n
      filter_upwards [] with t
      rw [norm_mul]
      apply mul_le_of_le_one_right (norm_nonneg _)
      induction t using Quotient.inductionOn with | h t =>
        exact circleSmoothApprox_bound (fun t ↦ by simpa only [Real.norm_eq_abs] using hb (t : AxisCircle)) n t
    · filter_upwards [circleSmoothApprox_lift_ae_tendsto hf hb] with t ht
      exact tendsto_const_nhds.mul ht
  have hh : 0≤∫ t,h t*f t := ge_of_tendsto hl (Eventually.of_forall fun n ↦
    hw _ (hc n) (circleSmoothApprox_periodic hp n) (circleSmoothApprox_nonneg hn n))
  have he : (fun t ↦ h t*f t)=s.indicator h := by
    funext t
    by_cases ht : t∈s <;> simp [f,ht]
  rwa [he,integral_indicator hs] at hh

end CubicTorus

end
end

section

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

def axialSliceIntegral (E : Set Torus) (i : Fin 3) (f : Torus → ℝ) (t : AxisCircle) : ℝ :=
  ∫ y in axialSlice E i t,f ((torusAxialSplit i).symm (t,y))

lemma axialSliceIntegral_indicator {E : Set Torus} (hE : MeasurableSet E) (i : Fin 3)
    (f : Torus → ℝ) (t : AxisCircle) :
    axialSliceIntegral E i f t=∫ y,E.indicator f ((torusAxialSplit i).symm (t,y)) := by
  rw [axialSliceIntegral,←integral_indicator (axialSlice_measurable hE i t)]
  congr 1

lemma axialSliceIntegral_integrable {E : Set Torus} (hE : MeasurableSet E) (i : Fin 3)
    {f : Torus → ℝ} (hf : Integrable f torusVolume) : Integrable (axialSliceIntegral E i f) := by
  have hg := (torusAxialSplit_measurePreserving i).symm.integrable_comp_of_integrable (hf.indicator hE)
  have hh := hg.integral_prod_left
  simpa only [Function.comp_apply,←axialSliceIntegral_indicator hE] using hh

lemma axialSliceIntegral_pairing {E : Set Torus} (hE : MeasurableSet E) (i : Fin 3)
    {f : Torus → ℝ} (hf : Continuous f) {ψ : AxisCircle → ℝ} (hψ : Continuous ψ) :
    (∫ t,ψ t*axialSliceIntegral E i f t)=∫ z in E,ψ (z i)*f z ∂torusVolume := by
  have hi : Integrable (fun z : Torus ↦ ψ (z i)*f z) torusVolume :=
    ((hψ.comp (PiLp.continuous_apply 2 _ i)).mul hf).integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _)
  have hg := (torusAxialSplit_measurePreserving i).symm.integrable_comp_of_integrable (hi.indicator hE)
  rw [←integral_indicator hE,←(torusAxialSplit_measurePreserving i).symm.integral_comp'
    (E.indicator (fun z : Torus ↦ ψ (z i)*f z))]
  change _=∫ z,((E.indicator (fun z : Torus ↦ ψ (z i)*f z)) ∘ (torusAxialSplit i).symm) z ∂volume.prod volume
  rw [integral_prod _ hg]
  apply integral_congr_ae
  filter_upwards [] with t
  rw [axialSliceIntegral_indicator hE,←integral_const_mul]
  apply integral_congr_ae
  filter_upwards [] with y
  by_cases hy : (torusAxialSplit i).symm (t,y)∈E <;> simp [hy]

lemma normal_transverse_inner_bound (i : Fin 3) (z : NormalBundle) (v : Cover)
    (hv : v i=0) (hb : ‖v‖≤1) : ⟪(z.2 : Cover),v⟫≤normalTransverseLength i z := by
  let n : Cover := (z.2 : Cover)-((z.2 : Cover) i) • EuclideanSpace.single i 1
  have hn : ‖n‖=normalTransverseLength i z := by
    apply (sq_eq_sq₀ (norm_nonneg _) (normalTransverseLength_nonneg i z)).mp
    have hz : ‖(z.2 : Cover)‖=1 := z.2.property
    have hs := normalTransverseLength_sq i z
    dsimp only [n]
    rw [norm_sub_sq_real,real_inner_smul_right,EuclideanSpace.inner_single_right,norm_smul,
      PiLp.norm_single,Real.norm_eq_abs,Real.norm_eq_abs,abs_one,mul_one,hz]
    simp only [conj_trivial,one_mul] at *
    nlinarith [sq_abs ((z.2 : Cover) i)]
  have he : ⟪n,v⟫=⟪(z.2 : Cover),v⟫ := by
    simp [n,inner_sub_left,real_inner_smul_left,EuclideanSpace.inner_single_left,hv]
  rw [←he]
  calc
    _ ≤ ‖n‖*‖v‖ := real_inner_le_norm _ _
    _ ≤ ‖n‖ := mul_le_of_le_one_right (norm_nonneg _) hb
    _ = _ := hn

lemma axialPerimeterDensity_pairing_continuous {μ : FiniteMeasure NormalBundle} (i : Fin 3)
    (ha : (axialAreaMarginal μ i : Measure AxisCircle)≪volume)
    {f : AxisCircle → ℝ} (hf : Continuous f) :
    (∫ t,axialPerimeterDensity μ i t*f t)=
      ∫ z,normalTransverseLength i z*f (((z.1 : Cover) i) : AxisCircle) ∂(μ : Measure NormalBundle) := by
  have hp := axialPerimeterMarginal_absolutelyContinuous i ha
  change (∫ t,((axialPerimeterMarginal μ i : Measure AxisCircle).rnDeriv volume t).toReal*f t)=_
  rw [integral_toReal_rnDeriv_mul hp]
  change (∫ t,f t ∂Measure.map _ _)=_
  rw [integral_map (normal_axisCircle_continuous i).measurable.aemeasurable hf.aestronglyMeasurable]
  rw [integral_withDensity_eq_integral_toReal_smul
    (normalTransverseLength_continuous i).measurable.ennreal_ofReal
    (ae_of_all _ fun _ ↦ ENNReal.ofReal_lt_top)]
  apply integral_congr_ae
  filter_upwards [] with z
  rw [ENNReal.toReal_ofReal (normalTransverseLength_nonneg i z),smul_eq_mul]

end CubicTorus

end
end

section

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

lemma axial_weight_divergence {i : Fin 3} {F : Cover → Cover}
    (hF : ContDiff ℝ (⊤ : ℕ∞) F) (hFi : ∀ x,F x i=0)
    {ψ : ℝ → ℝ} (hψ : ContDiff ℝ (⊤ : ℕ∞) ψ) (x : Cover) :
    divergence (fun y : Cover ↦ ψ (y i) • F y) x=ψ (x i)*divergence F x := by
  have hd : DifferentiableAt ℝ (fun y : Cover ↦ ψ (y i)) x :=
    ((hψ.comp (EuclideanSpace.proj i : Cover →L[ℝ] ℝ).contDiff).differentiable (by simp)).differentiableAt
  rw [divergence_smul_function hd
    (hF.differentiable (by simp)).differentiableAt,inner_gradient_left,
    axial_scalar_fderiv (hψ.differentiable (by simp)),hFi,mul_zero,add_zero]

theorem axialSliceIntegral_weighted_le {E : Set Torus} (hE : MeasurableSet E)
    {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) (i : Fin 3)
    (ha : (axialAreaMarginal μ i : Measure AxisCircle)≪volume)
    {F : Cover → Cover} (hF : AdmissibleField F) (hFi : ∀ x,F x i=0)
    {ψ : ℝ → ℝ} (hψ : ContDiff ℝ (⊤ : ℕ∞) ψ) (hp : Function.Periodic ψ 1)
    (hn : ∀ t,0≤ψ t) :
    (∫ t,hp.lift t*axialSliceIntegral E i (fun z ↦ divergence F (representative z)) t)≤
      ∫ t,hp.lift t*axialPerimeterDensity μ i t := by
  let G : Cover → Cover := fun x ↦ ψ (x i) • F x
  have hG : ContDiff ℝ (⊤ : ℕ∞) G :=
    (hψ.comp (EuclideanSpace.proj i : Cover →L[ℝ] ℝ).contDiff).smul hF.1
  have hGp : ∀ m x,G (x+latticeVector m)=G x := by
    intro m x
    dsimp only [G]
    rw [axial_scalar_periodic hp i m x,hF.2.1]
  obtain ⟨C,hC,hCb⟩ := periodic_bounded hG.continuous hGp
  have hflux := normalMeasure_flux hμ hG hGp (show 0<C+1 by linarith) (fun x ↦ (hCb x).trans (by linarith))
  have hd : Continuous (fun z : Torus ↦ divergence F (representative z)) :=
    continuous_periodic_descent (continuous_divergence hF.1) (divergence_periodic hF.2.1)
  have hp' := continuous_periodic_lift hp hψ.continuous
  rw [axialSliceIntegral_pairing hE i hd hp']
  have he : (fun z : Torus ↦ hp.lift (z i)*divergence F (representative z))=
      (fun z : Torus ↦ divergence G (representative z)) := by
    funext z
    rw [axial_weight_divergence hF.1 hFi hψ]
    congr 1
    have hh := congrArg (fun a : Torus ↦ hp.lift (a i)) (quotientMap_representative z)
    exact hh.symm
  rw [he,setIntegral_lift (continuous_divergence hG) (divergence_periodic hGp) hE,←hflux]
  simp_rw [mul_comm (hp.lift _) (axialPerimeterDensity μ i _)]
  rw [axialPerimeterDensity_pairing_continuous i ha hp']
  apply integral_mono
  · exact (normalTest G hG.continuous).continuous.integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _)
  · exact ((normalTransverseLength_continuous i).mul (hp'.comp (normal_axisCircle_continuous i))).integrable_of_hasCompactSupport (HasCompactSupport.of_compactSpace _)
  · intro z
    change ⟪(z.2 : Cover),ψ ((z.1 : Cover) i) • F z.1⟫≤_
    simp only [real_inner_smul_right,Function.Periodic.lift_coe]
    rw [mul_comm (normalTransverseLength i z)]
    exact mul_le_mul_of_nonneg_left (normal_transverse_inner_bound i z _ (hFi _) (hF.2.2 _)) (hn _)

theorem axialSliceIntegral_ae_le {E : Set Torus} (hE : MeasurableSet E)
    {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) (i : Fin 3)
    (ha : (axialAreaMarginal μ i : Measure AxisCircle)≪volume)
    {F : Cover → Cover} (hF : AdmissibleField F) (hFi : ∀ x,F x i=0) :
    axialSliceIntegral E i (fun z ↦ divergence F (representative z))≤ᵐ[volume]axialPerimeterDensity μ i := by
  have hd : Continuous (fun z : Torus ↦ divergence F (representative z)) :=
    continuous_periodic_descent (continuous_divergence hF.1) (divergence_periodic hF.2.1)
  have hdI := hd.integrable_of_hasCompactSupport (μ := torusVolume) (HasCompactSupport.of_compactSpace _)
  have hs := axialSliceIntegral_integrable hE i hdI
  have hi := axialPerimeterDensity_integrable μ i
  have hh := integrable_circle_nonneg_of_smooth_pairing (hi.sub hs) (by
    intro ψ hψ hp hn
    have hc := continuous_periodic_lift hp hψ.continuous
    simp only [Pi.sub_apply,sub_mul]
    rw [integral_sub (circle_integrable_mul_continuous hi hc) (circle_integrable_mul_continuous hs hc)]
    apply sub_nonneg.mpr
    simpa only [mul_comm] using axialSliceIntegral_weighted_le hE hμ i ha hF hFi hψ hp hn)
  filter_upwards [hh] with t ht
  exact sub_nonneg.mp ht

end CubicTorus

end
end

section

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

lemma axialSection_integrable (E : Set Torus) (i : Fin 3) (t : AxisCircle) (f : C(Torus,ℝ)) :
    Integrable (fun y : TransverseProduct ↦ f ((torusAxialSplit i).symm (t,y)))
      (volume.restrict (axialSlice E i t)) := by
  apply Integrable.of_bound
    (f.continuous.measurable.comp ((torusAxialSplit i).symm.measurable.comp
      (measurable_const.prodMk measurable_id))).aestronglyMeasurable ‖f‖
  exact ae_of_all _ fun y ↦ f.norm_coe_le_norm _

def axialSliceFunctional (E : Set Torus) (i : Fin 3) (t : AxisCircle) : C(Torus,ℝ) →L[ℝ] ℝ :=
  LinearMap.mkContinuous
    { toFun := fun f ↦ axialSliceIntegral E i f t
      map_add' := by
        intro f g
        exact integral_add (axialSection_integrable E i t f) (axialSection_integrable E i t g)
      map_smul' := by
        intro c f
        exact integral_const_mul c (fun y : TransverseProduct ↦ f ((torusAxialSplit i).symm (t,y))) }
    1 (by
      intro f
      have hh := norm_setIntegral_le_of_norm_le_const (measure_lt_top volume (axialSlice E i t))
        (fun y (_ : y∈axialSlice E i t) ↦ f.norm_coe_le_norm ((torusAxialSplit i).symm (t,y)))
      have hm : (volume (axialSlice E i t)).toReal≤1 := by
        simpa only [axialSliceVolume,ENNReal.toReal_one] using ENNReal.toReal_mono (by simp : (1 : ℝ≥0∞)≠∞) (axialSliceVolume_le_one E i t)
      change ‖axialSliceIntegral E i f t‖≤1*‖f‖
      simpa only [one_mul,axialSliceIntegral] using hh.trans (mul_le_of_le_one_right (norm_nonneg f) hm))

def axialDivergenceClass (i : Fin 3) : Set C(Torus,ℝ) :=
  {f | ∃ (F : Cover → Cover) (hF : AdmissibleField F),
    (∀ x,F x i=0) ∧ f=⟨fun z ↦ divergence F (representative z),
      continuous_periodic_descent (continuous_divergence hF.1) (divergence_periodic hF.2.1)⟩}

theorem axialSliceIntegral_ae_all_le {E : Set Torus} (hE : MeasurableSet E)
    {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) (i : Fin 3)
    (ha : (axialAreaMarginal μ i : Measure AxisCircle)≪volume) :
    ∀ᵐ t : AxisCircle,∀ (F : Cover → Cover) (_hF : AdmissibleField F),
      (∀ x,F x i=0) →
      axialSliceIntegral E i (fun z ↦ divergence F (representative z)) t≤axialPerimeterDensity μ i t := by
  obtain ⟨S,hS,hSc,hSd⟩ := (TopologicalSpace.IsSeparable.of_separableSpace (axialDivergenceClass i)).exists_countable_dense_subset
  have hh : ∀ f∈S,∀ᵐ t : AxisCircle,axialSliceFunctional E i t f≤axialPerimeterDensity μ i t := by
    intro f hf
    obtain ⟨F,hF,hFi,rfl⟩ := hS hf
    exact axialSliceIntegral_ae_le hE hμ i ha hF hFi
  filter_upwards [(ae_ball_iff hSc).mpr hh] with t ht
  intro F hF hFi
  let f : C(Torus,ℝ) := ⟨fun z ↦ divergence F (representative z),
    continuous_periodic_descent (continuous_divergence hF.1) (divergence_periodic hF.2.1)⟩
  have hf : f∈axialDivergenceClass i := ⟨F,hF,hFi,rfl⟩
  have hc : IsClosed {f : C(Torus,ℝ) | axialSliceFunctional E i t f≤axialPerimeterDensity μ i t} :=
    isClosed_le (axialSliceFunctional E i t).continuous continuous_const
  exact (closure_minimal ht hc) (hSd hf)

def axialTestPerimeter (E : Set Torus) (i : Fin 3) (t : AxisCircle) : ℝ≥0∞ :=
  ⨆ (F : Cover → Cover) (_ : AdmissibleField F) (_ : ∀ x,F x i=0),
    ENNReal.ofReal (axialSliceIntegral E i (fun z ↦ divergence F (representative z)) t)

theorem axialTestPerimeter_ae_le {E : Set Torus} (hE : MeasurableSet E)
    {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) (i : Fin 3)
    (ha : (axialAreaMarginal μ i : Measure AxisCircle)≪volume) :
    ∀ᵐ t : AxisCircle,axialTestPerimeter E i t≤ENNReal.ofReal (axialPerimeterDensity μ i t) := by
  filter_upwards [axialSliceIntegral_ae_all_le hE hμ i ha] with t ht
  exact iSup_le fun F ↦ iSup_le fun hF ↦ iSup_le fun hFi ↦ ENNReal.ofReal_le_ofReal (ht F hF hFi)

end CubicTorus

end
end

section

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

def planeAxisEmbedding (i : Fin 3) : Plane →L[ℝ] Cover :=
  LinearMap.toContinuousLinearMap
    { toFun := fun y ↦ WithLp.toLp 2 (i.insertNth 0 y.ofLp)
      map_add' := by
        intro x y; ext j
        rcases Fin.eq_self_or_eq_succAbove i j with rfl|⟨k,rfl⟩ <;> simp
      map_smul' := by
        intro a x; ext j
        rcases Fin.eq_self_or_eq_succAbove i j with rfl|⟨k,rfl⟩ <;> simp }

def planeAxisProjection (i : Fin 3) : Cover →L[ℝ] Plane :=
  LinearMap.toContinuousLinearMap
    { toFun := fun x ↦ WithLp.toLp 2 (fun j ↦ x (i.succAbove j))
      map_add' := by intro x y; rfl
      map_smul' := by intro a x; rfl }

@[simp] lemma planeAxisEmbedding_same (i : Fin 3) (y : Plane) :
    planeAxisEmbedding i y i=0 := by
  change i.insertNth (α := fun _ : Fin 3 ↦ ℝ) 0 y.ofLp i=0
  exact Fin.insertNth_apply_same (α := fun _ : Fin 3 ↦ ℝ) i 0 y.ofLp
@[simp] lemma planeAxisEmbedding_succAbove (i : Fin 3) (y : Plane) (j : Fin 2) :
    planeAxisEmbedding i y (i.succAbove j)=y j := by
  change i.insertNth (α := fun _ : Fin 3 ↦ ℝ) 0 y.ofLp (i.succAbove j)=y j
  exact Fin.insertNth_apply_succAbove (α := fun _ : Fin 3 ↦ ℝ) i 0 y.ofLp j
@[simp] lemma planeAxisProjection_apply (i : Fin 3) (x : Cover) (j : Fin 2) :
    planeAxisProjection i x j=x (i.succAbove j) := rfl

lemma planeAxisEmbedding_norm (i : Fin 3) (y : Plane) : ‖planeAxisEmbedding i y‖=‖y‖ := by
  apply (sq_eq_sq₀ (norm_nonneg _) (norm_nonneg _)).mp
  rw [PiLp.norm_sq_eq_of_L2,PiLp.norm_sq_eq_of_L2,Fin.sum_univ_succAbove _ i]
  simp

lemma planeAxisProjection_norm_le (i : Fin 3) (x : Cover) : ‖planeAxisProjection i x‖≤‖x‖ := by
  have hh : ‖planeAxisProjection i x‖^2≤‖x‖^2 := by
    rw [PiLp.norm_sq_eq_of_L2,PiLp.norm_sq_eq_of_L2,Fin.sum_univ_succAbove _ i]
    simp only [planeAxisProjection_apply]
    nlinarith [sq_nonneg ‖x i‖]
  nlinarith [norm_nonneg (planeAxisProjection i x),norm_nonneg x]

@[simp] lemma planeAxisProjection_embedding (i : Fin 3) (y : Plane) :
    planeAxisProjection i (planeAxisEmbedding i y)=y := by ext j; simp

@[simp] lemma planeAxisProjection_single_same (i : Fin 3) :
    planeAxisProjection i (EuclideanSpace.single i 1)=0 := by
  ext j
  simp [Fin.succAbove_ne]

@[simp] lemma planeAxisProjection_single_succAbove (i : Fin 3) (j : Fin 2) :
    planeAxisProjection i (EuclideanSpace.single (i.succAbove j) 1)=EuclideanSpace.single j 1 := by
  ext k
  simp [Fin.succAbove_right_injective.eq_iff]

def PlanarAdmissibleField (G : Plane → Plane) : Prop :=
  ContDiff ℝ (⊤ : ℕ∞) G ∧
  (∀ (n : Fin 2 → ℤ) (y : Plane),G (y+WithLp.toLp 2 (fun j ↦ (n j : ℝ)))=G y) ∧
  ∀ y,‖G y‖≤1

def liftPlanarField (i : Fin 3) (G : Plane → Plane) (x : Cover) : Cover :=
  planeAxisEmbedding i (G (planeAxisProjection i x))

lemma liftPlanarField_admissible (i : Fin 3) {G : Plane → Plane}
    (hG : PlanarAdmissibleField G) : AdmissibleField (liftPlanarField i G) := by
  refine ⟨(planeAxisEmbedding i).contDiff.comp (hG.1.comp (planeAxisProjection i).contDiff),?_,?_⟩
  · intro n x
    unfold liftPlanarField
    rw [map_add]
    exact congrArg (planeAxisEmbedding i) (hG.2.1 (fun j ↦ n (i.succAbove j)) _)
  · intro x
    rw [liftPlanarField,planeAxisEmbedding_norm]
    exact hG.2.2 _

@[simp] lemma liftPlanarField_same (i : Fin 3) (G : Plane → Plane) (x : Cover) :
    liftPlanarField i G x i=0 := planeAxisEmbedding_same _ _

lemma divergence_liftPlanarField (i : Fin 3) {G : Plane → Plane}
    (hG : ContDiff ℝ (⊤ : ℕ∞) G) (x : Cover) :
    divergence (liftPlanarField i G) x=planeDivergence G (planeAxisProjection i x) := by
  have hd := (planeAxisEmbedding i).hasFDerivAt.comp x
    (((hG.differentiable (by simp) (planeAxisProjection i x)).hasFDerivAt).comp x
      (planeAxisProjection i).hasFDerivAt)
  change HasFDerivAt (liftPlanarField i G) _ x at hd
  rw [divergence,hd.fderiv,Fin.sum_univ_succAbove _ i]
  simp [ContinuousLinearMap.comp_apply,planeDivergence,Fin.sum_univ_two]

end CubicTorus

end
end

section

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

@[simp] lemma planeAxisEmbedding_single (i : Fin 3) (j : Fin 2) :
    planeAxisEmbedding i (EuclideanSpace.single j 1)=EuclideanSpace.single (i.succAbove j) 1 := by
  ext k
  rcases Fin.eq_self_or_eq_succAbove i k with rfl|⟨k,rfl⟩
  · simp
  · simp [Fin.succAbove_right_injective.eq_iff]

def planeAxisAt (i : Fin 3) (a : ℝ) (y : Plane) : Cover :=
  a • EuclideanSpace.single i 1+planeAxisEmbedding i y

@[simp] lemma planeAxisAt_same (i : Fin 3) (a : ℝ) (y : Plane) : planeAxisAt i a y i=a := by
  simp [planeAxisAt]
@[simp] lemma planeAxisAt_succAbove (i : Fin 3) (a : ℝ) (y : Plane) (j : Fin 2) :
    planeAxisAt i a y (i.succAbove j)=y j := by
  simp [planeAxisAt,Fin.succAbove_ne]

lemma planeAxisAt_contDiff (i : Fin 3) (a : ℝ) : ContDiff ℝ (⊤ : ℕ∞) (planeAxisAt i a) :=
  contDiff_const.add (planeAxisEmbedding i).contDiff

lemma planeAxisAt_hasFDerivAt (i : Fin 3) (a : ℝ) (y : Plane) :
    HasFDerivAt (planeAxisAt i a) (planeAxisEmbedding i) y := by
  exact (planeAxisEmbedding i).hasFDerivAt.const_add (a • EuclideanSpace.single i (1 : ℝ))

def tracePlanarField (i : Fin 3) (a : ℝ) (F : Cover → Cover) (y : Plane) : Plane :=
  planeAxisProjection i (F (planeAxisAt i a y))

lemma tracePlanarField_admissible (i : Fin 3) (a : ℝ) {F : Cover → Cover}
    (hF : AdmissibleField F) : PlanarAdmissibleField (tracePlanarField i a F) := by
  refine ⟨(planeAxisProjection i).contDiff.comp (hF.1.comp (planeAxisAt_contDiff i a)),?_,?_⟩
  · intro n y
    have he : planeAxisAt i a (y+WithLp.toLp 2 (fun j ↦ (n j : ℝ)))=
        planeAxisAt i a y+latticeVector (i.insertNth (α := fun _ : Fin 3 ↦ ℤ) 0 n) := by
      ext k
      rcases Fin.eq_self_or_eq_succAbove i k with rfl|⟨k,rfl⟩ <;>
        simp [latticeVector,planeAxisAt,map_add,add_assoc]
    unfold tracePlanarField
    rw [he,hF.2.1]
  · intro y
    exact (planeAxisProjection_norm_le i _).trans (hF.2.2 _)

lemma planeDivergence_tracePlanarField (i : Fin 3) (a : ℝ) {F : Cover → Cover}
    (hF : ContDiff ℝ (⊤ : ℕ∞) F) (hFi : ∀ x,F x i=0) (y : Plane) :
    planeDivergence (tracePlanarField i a F) y=divergence F (planeAxisAt i a y) := by
  have hd := (planeAxisProjection i).hasFDerivAt.comp y
    (((hF.differentiable (by simp) (planeAxisAt i a y)).hasFDerivAt).comp y
      (planeAxisAt_hasFDerivAt i a y))
  change HasFDerivAt (tracePlanarField i a F) _ y at hd
  have hz : (fderiv ℝ F (planeAxisAt i a y) (EuclideanSpace.single i 1)) i=0 := by
    rw [←fderiv_component (hF.differentiable (by simp) _) i]
    simp only [hFi]
    simp
  rw [planeDivergence,hd.fderiv,divergence,Fin.sum_univ_succAbove _ i,hz]
  simp [ContinuousLinearMap.comp_apply,Fin.sum_univ_two]

def planarRepresentative (y : TransverseProduct) : Plane :=
  WithLp.toLp 2 (fun j ↦ ((AddCircle.equivIco (1 : ℝ) 0) (y j) : ℝ))

lemma planeAxisProjection_representative (i : Fin 3) (t : AxisCircle) (y : TransverseProduct) :
    planeAxisProjection i (representative ((torusAxialSplit i).symm (t,y)))=planarRepresentative y := by
  ext j
  simp [representative,planarRepresentative]

lemma representative_axialSplit (i : Fin 3) (t : AxisCircle) (y : TransverseProduct) :
    representative ((torusAxialSplit i).symm (t,y))=
      planeAxisAt i (((AddCircle.equivIco (1 : ℝ) 0) t) : ℝ) (planarRepresentative y) := by
  ext k
  rcases Fin.eq_self_or_eq_succAbove i k with rfl|⟨k,rfl⟩ <;>
    simp [representative,planarRepresentative]

def planarTorusPerimeter (A : Set TransverseProduct) : ℝ≥0∞ :=
  ⨆ (G : Plane → Plane) (_ : PlanarAdmissibleField G),
    ENNReal.ofReal (∫ y in A,planeDivergence G (planarRepresentative y))

theorem axialTestPerimeter_eq_planar (E : Set Torus) (i : Fin 3) (t : AxisCircle) :
    axialTestPerimeter E i t=planarTorusPerimeter (axialSlice E i t) := by
  apply le_antisymm
  · refine iSup_le fun F ↦ iSup_le fun hF ↦ iSup_le fun hFi ↦ ?_
    let a : ℝ := ((AddCircle.equivIco (1 : ℝ) 0) t : ℝ)
    have hb : ENNReal.ofReal (∫ y in axialSlice E i t,
        planeDivergence (tracePlanarField i a F) (planarRepresentative y))≤
        planarTorusPerimeter (axialSlice E i t) :=
      le_iSup_of_le (tracePlanarField i a F)
        (le_iSup_of_le (tracePlanarField_admissible i a hF) le_rfl)
    apply le_trans _ hb
    apply le_of_eq
    congr 1
    unfold axialSliceIntegral
    apply integral_congr_ae
    filter_upwards [] with y
    rw [planeDivergence_tracePlanarField i a hF.1 hFi,representative_axialSplit]
  · refine iSup_le fun G ↦ iSup_le fun hG ↦ ?_
    have hb : ENNReal.ofReal (axialSliceIntegral E i
        (fun z ↦ divergence (liftPlanarField i G) (representative z)) t)≤axialTestPerimeter E i t :=
      le_iSup_of_le (liftPlanarField i G)
        (le_iSup_of_le (liftPlanarField_admissible i hG)
          (le_iSup_of_le (liftPlanarField_same i G) le_rfl))
    apply le_trans _ hb
    apply le_of_eq
    congr 1
    unfold axialSliceIntegral
    apply integral_congr_ae
    filter_upwards [] with y
    rw [divergence_liftPlanarField i hG.1,planeAxisProjection_representative]

theorem planarTorusPerimeter_slice_ae_le {E : Set Torus} (hE : MeasurableSet E)
    {μ : FiniteMeasure NormalBundle} (hμ : IsNormalMeasure E μ) (i : Fin 3)
    (ha : (axialAreaMarginal μ i : Measure AxisCircle)≪volume) :
    ∀ᵐ t : AxisCircle,planarTorusPerimeter (axialSlice E i t)≤ENNReal.ofReal (axialPerimeterDensity μ i t) := by
  simpa only [axialTestPerimeter_eq_planar] using axialTestPerimeter_ae_le hE hμ i ha

end CubicTorus

end
end

section

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

def planarAxialField (j : Fin 2) (ψ : ℝ → ℝ) (y : Plane) : Plane :=
  ψ (y j) • EuclideanSpace.single j 1

end CubicTorus
end
end
end

end OAI