import Mathlib
import OAI.Geometry.CubicTorus.Profiles.NestingBaseline

namespace OAI

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

theorem isMinimizerAt_nonstandard_sharp_flux {V : ℝ} (hV : V∈Ioc 0 (1/2))
    {E : Set Torus} (hmin : IsMinimizerAt V E) (hstd : ¬StandardRegionAt V E)
    (hR : ∀ i : Fin 3,E=ᵐ[torusVolume]((axisReflection i).torus ⁻¹' E)) :
    ∃ (μ : FiniteMeasure NormalBundle) (H : ℝ) (b : Fin 3 →Bool),
      IsNormalMeasure E μ ∧
      (∀ 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))) ∧
      (∀ x∈upperOctant,∀ y∈upperOctant,OrientedCoordinateLE b x y →
        quotientMap y∈openRepresentative E →quotientMap x∈openRepresentative E) ∧
      (∀ i : Fin 3,(axialAreaMarginal μ i : Measure AxisCircle)≪volume) ∧
      ∀ i : Fin 3,
        quotientMap (orientedUpperVertex b (fun j ↦ if j=i then true else false))∉openRepresentative E →
        0≤H ∧ Nesting.lambda*H*V+2*(∫ s in (0 : ℝ)..
          (axialSliceVolume (openRepresentative E) i (octantHeight b i 0 : AxisCircle)).toReal,
            sharpSectionWeight H s)≤(perimeter E).toReal := by
  have hV' : V∈Ioo (0 : ℝ) 1 := ⟨hV.1,by linarith [hV.2]⟩
  have hc : IsPreconnected (frontier (openRepresentative E)) :=
    (Periodic.isMinimizerAt_connected_or_standard_slab hV' hmin).resolve_right (fun h ↦ hstd h.2.2)
  obtain ⟨b,hd⟩ := isMinimizerAt_octant_downset hV' hmin hc hR
  obtain ⟨μ,H,hμ,hCMC,ha,_⟩ := isMinimizerAt_nonstandard_integrated_flux hV hmin hstd hR
  refine ⟨μ,H,b,hμ,hCMC,hd,ha,fun i hv ↦ ?_⟩
  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 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 hHF := Periodic.coordinateCMC_of_global hμF hCMC
  have hf := isMinimizerAt_missing_neighbor_flux_unrestricted hV' hF hmF hRF b hdF hμF hHF i hvF
  have hH0 : 0≤H := by
    have hh := axialTransverseMass_nonneg μ i
    rw [hf] at hh
    exact nonneg_of_mul_nonneg_left hh hV.1
  refine ⟨hH0,?_⟩
  have hh := isMinimizerAt_missing_neighbor_sharp_area_flux hV' hF hmF hRF b hdF hμF hH0 hHF i (ha i) hvF
  rwa [ho,perimeter_congr_ae hFE] at hh

end CubicTorus

end
end

section

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

theorem isMinimizerAt_nonstandard_three_vertex_nesting {E : Set Torus}
    (hmin : IsMinimizerAt (1/Real.pi) E) (hstd : ¬StandardRegionAt (1/Real.pi) E)
    (hR : ∀ i : Fin 3,E=ᵐ[torusVolume]((axisReflection i).torus ⁻¹' E)) :
    ∃ (μ : FiniteMeasure NormalBundle) (H : ℝ) (b : Fin 3 →Bool),
      IsNormalMeasure E μ ∧
      (∀ 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))) ∧
      (∀ x∈upperOctant,∀ y∈upperOctant,OrientedCoordinateLE b x y →
        quotientMap y∈openRepresentative E →quotientMap x∈openRepresentative E) ∧
      (∀ i : Fin 3,(axialAreaMarginal μ i : Measure AxisCircle)≪volume) ∧
      ∀ i : Fin 3,
        quotientMap (orientedUpperVertex b (fun j ↦ if j=i then true else false))∉openRepresentative E →
        (∀ j : Fin 2,quotientMap (orientedUpperVertex b (fun k ↦ if k=i.succAbove j then true else false))∈openRepresentative E) →
        let s := volume.real (axialSlice (openRepresentative E) i (octantHeight b i 0 : AxisCircle))
        (perimeter E).toReal/2 ≤ 1 ∧
        Real.sqrt (Real.pi*(1-s))/s ≤ H/2 ∧ H/2 ≤ Real.pi*(1-s^2) ∧
        s∈Ioo (107/200 : ℝ) (89/100 : ℝ) ∧ H/2∈Icc (16/25 : ℝ) (9/4 : ℝ) ∧ Shape.t (H/2) ≤ s ∧
        nestingBaseline (H/2) ≤ (perimeter E).toReal/2-1 ∧
        (H/2∈Icc (51/50 : ℝ) (81/50 : ℝ) →
          nestingBaseline (H/2)+nestingGainInfimum (H/2) ≤ (perimeter E).toReal/2-1) := by
  have hV : (1/Real.pi)∈Ioo (0 : ℝ) 1 := ⟨by positivity,(div_lt_one Real.pi_pos).mpr (by linarith [Real.pi_gt_three])⟩
  have hVh : (1/Real.pi)∈Ioc (0 : ℝ) (1/2) := ⟨hV.1,by rw [div_le_iff₀ Real.pi_pos]; linarith [Real.pi_gt_three]⟩
  have hc : IsPreconnected (frontier (openRepresentative E)) :=
    (Periodic.isMinimizerAt_connected_or_standard_slab hV hmin).resolve_right (fun h ↦ hstd h.2.2)
  obtain ⟨μ,H,b,hμ,hCMC,hd,ha,hf⟩ := isMinimizerAt_nonstandard_sharp_flux hVh hmin hstd hR
  refine ⟨μ,H,b,hμ,hCMC,hd,ha,fun i hv haxes ↦ ?_⟩
  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 haxesF : ∀ j : Fin 2,quotientMap (orientedUpperVertex b (fun k ↦ if k=i.succAbove j then true else false))∈openRepresentative F := by rwa [ho]
  have hμF := hμ.congr_ae hFE.symm
  obtain ⟨hA,hlo,hhi,hs,hcurv,ht⟩ := isMinimizerAt_three_vertex_parameters hF hmF hcF hRF b hdF hμF hCMC i (ha i) hvF haxesF
  simp only [ho,perimeter_congr_ae hFE] at hA hlo hhi hs hcurv ht
  refine ⟨hA,hlo,hhi,hs,hcurv,ht,?_,fun hH ↦ ?_⟩
  · have hh0 : 0 ≤ H/2 := by linarith [hcurv.1]
    have hb := nestingBaseline_slack hh0 ht
    rw [show 2*(H/2)=H by ring] at hb
    have hflux := (hf i hv).2
    change Nesting.lambda*H*(1/Real.pi)+2*(∫ v in (0 : ℝ)..
      volume.real (axialSlice (openRepresentative E) i (octantHeight b i 0 : AxisCircle)),sharpSectionWeight H v)≤(perimeter E).toReal at hflux
    have he : Nesting.lambda*H*(1/Real.pi)=2*(Nesting.lambda*(H/2)/Real.pi) := by ring
    rw [he] at hflux
    have hnon := mul_nonneg (show 0 ≤ Nesting.ell by norm_num [Nesting.ell]) (sub_nonneg.mpr ht)
    linarith
  ·
    obtain ⟨hout,hin⟩ := isMinimizerAt_three_vertex_bottom hV hmF hcF hRF b hdF i hvF haxesF
    have hh := isMinimizerAt_nesting_area_bound hF hmF hRF b hdF hμF hCMC i (ha i) hvF hout (hin 0) (hin 1) hH
    rwa [perimeter_congr_ae hFE] at hh

end CubicTorus

end
end

section

namespace ReusedScalar205

noncomputable section

namespace CubicTorus.Arithmetic
open Set Filter
open scoped Topology

def atanPoly (n : ℕ) (x : ℝ) : ℝ :=
  ∑ i ∈ Finset.range n, (-1 : ℝ) ^ i * x ^ (2 * i + 1) / ↑(2 * i + 1)

lemma atan_terms_antitone {x : ℝ} (hx : x ∈ Icc 0 1) :
    Antitone (fun n : ℕ ↦ x ^ (2 * n + 1) / ↑(2 * n + 1)) := by
  apply antitone_nat_of_succ_le
  intro n
  calc
    _ ≤ x ^ (2 * n + 1) / ↑(2 * (n + 1) + 1) :=
      div_le_div_of_nonneg_right (pow_le_pow_of_le_one hx.1 hx.2 (by omega)) (by positivity)
    _ ≤ _ := div_le_div_of_nonneg_left (pow_nonneg hx.1 _) (by positivity) (by norm_cast; omega)

lemma atanPoly_bounds {x : ℝ} (hx : x ∈ Ico 0 1) (n : ℕ) :
    atanPoly (2 * n) x ≤ Real.arctan x ∧ Real.arctan x ≤ atanPoly (2 * n + 1) x := by
  have hs := (Real.hasSum_arctan (show ‖x‖ < 1 by simpa only [Real.norm_eq_abs, abs_of_nonneg hx.1] using hx.2)).tendsto_sum_nat
  have ha := atan_terms_antitone ⟨hx.1, hx.2.le⟩
  have heq : (fun k : ℕ ↦ ∑ i ∈ Finset.range k, (-1 : ℝ) ^ i * (x ^ (2 * i + 1) / ↑(2 * i + 1))) =
      (fun k : ℕ ↦ ∑ i ∈ Finset.range k, (-1 : ℝ) ^ i * x ^ (2 * i + 1) / ↑(2 * i + 1)) := by
    funext k
    apply Finset.sum_congr rfl
    intro i _
    ring
  rw [← heq] at hs
  exact ⟨by simpa only [atanPoly, mul_div_assoc] using ha.alternating_series_le_tendsto hs n,
    by simpa only [atanPoly, mul_div_assoc] using ha.tendsto_le_alternating_series hs n⟩

def atanHalf (x : ℝ) : ℝ := x / (1 + Real.sqrt (1 + x ^ 2))

lemma atanHalf_spec {x : ℝ} (hx : 0 ≤ x) :
    0 ≤ atanHalf x ∧ atanHalf x < 1 ∧ 2 * Real.arctan (atanHalf x) = Real.arctan x := by
  have hs0 := Real.sqrt_nonneg (1 + x ^ 2)
  have hs := Real.sq_sqrt (by positivity : 0 ≤ 1 + x ^ 2)
  have hsx : x < Real.sqrt (1 + x ^ 2) := by nlinarith
  have hd : 0 < 1 + Real.sqrt (1 + x ^ 2) := by positivity
  have hz0 : 0 ≤ atanHalf x := div_nonneg hx hd.le
  have hz1 : atanHalf x < 1 := (div_lt_one hd).2 (by linarith)
  refine ⟨hz0, hz1, ?_⟩
  rw [Real.two_mul_arctan (by linarith) hz1]
  congr 1
  have hzden : 1 - atanHalf x ^ 2 ≠ 0 := by
    have := (sq_lt_sq₀ hz0 (by norm_num : (0 : ℝ) ≤ 1)).2 hz1
    nlinarith
  apply (div_eq_iff hzden).2
  unfold atanHalf
  field_simp
  nlinarith

def asinQuarterArg (z : ℝ) : ℝ :=
  atanHalf (z / (1 + Real.sqrt (1 - z ^ 2)))

lemma arcsin_quarter {z : ℝ} (hz : z ∈ Ico 0 1) :
    0 ≤ asinQuarterArg z ∧ asinQuarterArg z < 1 ∧
      Real.arcsin z = 4 * Real.arctan (asinQuarterArg z) := by
  let b := Real.sqrt (1 - z ^ 2)
  have hsq : z ^ 2 < 1 := by simpa only [one_pow] using (sq_lt_sq₀ hz.1 (by norm_num : (0 : ℝ) ≤ 1)).2 hz.2
  have hb0 : 0 < b := Real.sqrt_pos.2 (by linarith)
  have hb : b ^ 2 = 1 - z ^ 2 := Real.sq_sqrt (by linarith)
  let k := z / (1 + b)
  have hk0 : 0 ≤ k := div_nonneg hz.1 (by positivity)
  have hk1 : k < 1 := (div_lt_one (by positivity)).2 (by linarith [hz.2])
  obtain ⟨hv0, hv1, hv⟩ := atanHalf_spec hk0
  refine ⟨hv0, hv1, ?_⟩
  change Real.arcsin z = 4 * Real.arctan (atanHalf k)
  have hk : 2 * Real.arctan k = Real.arcsin z := by
    rw [Real.two_mul_arctan (by linarith) hk1, Real.arcsin_eq_arctan ⟨by linarith [hz.1], hz.2⟩]
    congr 1
    change 2 * k / (1 - k ^ 2) = z / b
    have hd : 1 - k ^ 2 ≠ 0 := by nlinarith
    apply (div_eq_div_iff hd hb0.ne').2
    dsimp [k]
    field_simp
    have hbz := congrArg (fun t : ℝ ↦ z * t) hb
    nlinarith only [hbz]
  linarith

lemma arcsin_enclosure {z l u : ℝ} (hz : z ∈ Ico 0 1)
    (hl : l ∈ Ico 0 1) (hu : u ∈ Ico 0 1)
    (hlo : l ≤ asinQuarterArg z) (hhi : asinQuarterArg z ≤ u) (n : ℕ) :
    4 * atanPoly (2 * n) l ≤ Real.arcsin z ∧
      Real.arcsin z ≤ 4 * atanPoly (2 * n + 1) u := by
  rw [(arcsin_quarter hz).2.2]
  exact ⟨mul_le_mul_of_nonneg_left ((atanPoly_bounds hl n).1.trans (Real.arctan_mono hlo)) (by norm_num),
    mul_le_mul_of_nonneg_left ((Real.arctan_mono hhi).trans (atanPoly_bounds hu n).2) (by norm_num)⟩

end CubicTorus.Arithmetic

namespace CubicTorus.Arithmetic

def Encl (x l u : ℝ) : Prop := l ≤ x ∧ x ≤ u

lemma Encl.exact (x : ℝ) : Encl x x x := ⟨le_rfl, le_rfl⟩

lemma Encl.widen {x l u L U : ℝ} (hx : Encl x l u) (hL : L ≤ l) (hU : u ≤ U) : Encl x L U :=
  ⟨hL.trans hx.1, hx.2.trans hU⟩

lemma Encl.neg {x l u L U : ℝ} (hx : Encl x l u) (hL : L ≤ -u) (hU : -l ≤ U) : Encl (-x) L U :=
  ⟨hL.trans (neg_le_neg hx.2), (neg_le_neg hx.1).trans hU⟩

lemma Encl.add {x y l u p q L U : ℝ} (hx : Encl x l u) (hy : Encl y p q)
    (hL : L ≤ l + p) (hU : u + q ≤ U) : Encl (x + y) L U :=
  ⟨hL.trans (add_le_add hx.1 hy.1), (add_le_add hx.2 hy.2).trans hU⟩

lemma Encl.sub {x y l u p q L U : ℝ} (hx : Encl x l u) (hy : Encl y p q)
    (hL : L ≤ l - q) (hU : u - p ≤ U) : Encl (x - y) L U :=
  ⟨hL.trans (sub_le_sub hx.1 hy.2), (sub_le_sub hx.2 hy.1).trans hU⟩

lemma Encl.mul_nonneg {x y l u p q L U : ℝ} (hx : Encl x l u) (hy : Encl y p q)
    (hl : 0 ≤ l) (hp : 0 ≤ p) (hL : L ≤ l * p) (hU : u * q ≤ U) : Encl (x * y) L U := by
  refine ⟨hL.trans (mul_le_mul hx.1 hy.1 hp (hl.trans hx.1)), ?_⟩
  exact (mul_le_mul hx.2 hy.2 (hp.trans hy.1) (hl.trans (hx.1.trans hx.2))).trans hU

lemma Encl.square {x l u L U : ℝ} (hx : Encl x l u) (hl : 0 ≤ l)
    (hL : L ≤ l ^ 2) (hU : u ^ 2 ≤ U) : Encl (x ^ 2) L U := by
  exact ⟨hL.trans (pow_le_pow_left₀ hl hx.1 2), (pow_le_pow_left₀ (hl.trans hx.1) hx.2 2).trans hU⟩

lemma Encl.div_nonneg {x y l u p q L U : ℝ} (hx : Encl x l u) (hy : Encl y p q)
    (hl : 0 ≤ l) (hp : 0 < p) (hL : L * q ≤ l) (hU : u ≤ U * p) : Encl (x / y) L U := by
  have hy0 := hp.trans_le hy.1
  have hq0 := hy0.trans_le hy.2
  have hu0 := hl.trans (hx.1.trans hx.2)
  have hU0 : 0 ≤ U := by nlinarith
  constructor
  · calc
      L ≤ l / q := (le_div_iff₀ hq0).2 hL
      _ ≤ x / y := div_le_div₀ (hl.trans hx.1) hx.1 hy0 hy.2
  · exact (div_le_iff₀ hy0).2 (hx.2.trans (hU.trans (mul_le_mul_of_nonneg_left hy.1 hU0)))

lemma Encl.sqrt {x l u L U : ℝ} (hx : Encl x l u)
    (hL0 : 0 ≤ L) (hU0 : 0 ≤ U) (hL : L ^ 2 ≤ l) (hU : u ≤ U ^ 2) : Encl (Real.sqrt x) L U := by
  have hx0 : 0 ≤ x := (sq_nonneg L).trans (hL.trans hx.1)
  exact ⟨(Real.le_sqrt hL0 hx0).2 (hL.trans hx.1), (Real.sqrt_le_iff).2 ⟨hU0, hx.2.trans hU⟩⟩

lemma Encl.min {x y l u p q L U : ℝ} (hx : Encl x l u) (hy : Encl y p q)
    (hL : L ≤ min l p) (hU : min u q ≤ U) : Encl (min x y) L U :=
  ⟨hL.trans (min_le_min hx.1 hy.1), (min_le_min hx.2 hy.2).trans hU⟩

lemma Encl.arcsin {z a b L U : ℝ} (hz : z ∈ Set.Ico 0 1)
    (ha : a ∈ Set.Ico 0 1) (hb : b ∈ Set.Ico 0 1)
    (harg : Encl (asinQuarterArg z) a b) (n : ℕ)
    (hL : L ≤ 4 * atanPoly (2 * n) a) (hU : 4 * atanPoly (2 * n + 1) b ≤ U) :
    Encl (Real.arcsin z) L U :=
  (arcsin_enclosure hz ha hb harg.1 harg.2 n).imp (hL.trans ·) (·.trans hU)

end CubicTorus.Arithmetic

namespace CubicTorus.Arithmetic

lemma Encl.mul_nonpos_nonneg {x y l u p q L U : ℝ} (hx : Encl x l u) (hy : Encl y p q)
    (hu : u ≤ 0) (hp : 0 ≤ p) (hL : L ≤ l * q) (hU : u * p ≤ U) : Encl (x * y) L U := by
  have hn : Encl (-x) (-u) (-l) := hx.neg le_rfl le_rfl
  have hm := hn.mul_nonneg hy (neg_nonneg.2 hu) hp (L := -U) (U := -L)
    (by nlinarith only [hU]) (by nlinarith only [hL])
  simpa only [neg_mul, neg_neg] using hm.neg le_rfl le_rfl

lemma Encl.mul_nonneg_nonpos {x y l u p q L U : ℝ} (hx : Encl x l u) (hy : Encl y p q)
    (hl : 0 ≤ l) (hq : q ≤ 0) (hL : L ≤ u * p) (hU : l * q ≤ U) : Encl (x * y) L U := by
  simpa only [mul_comm] using hy.mul_nonpos_nonneg hx hq hl (by simpa only [mul_comm] using hL)
    (by simpa only [mul_comm] using hU)

lemma Encl.mul_nonpos {x y l u p q L U : ℝ} (hx : Encl x l u) (hy : Encl y p q)
    (hu : u ≤ 0) (hq : q ≤ 0) (hL : L ≤ u * q) (hU : l * p ≤ U) : Encl (x * y) L U := by
  have hn : Encl (-x) (-u) (-l) := hx.neg le_rfl le_rfl
  have hn' : Encl (-y) (-q) (-p) := hy.neg le_rfl le_rfl
  simpa only [neg_mul_neg] using hn.mul_nonneg hn' (neg_nonneg.2 hu) (neg_nonneg.2 hq)
    (by simpa only [neg_mul_neg] using hL) (by simpa only [neg_mul_neg] using hU)

lemma Encl.div_nonpos {x y l u p q L U : ℝ} (hx : Encl x l u) (hy : Encl y p q)
    (hu : u ≤ 0) (hp : 0 < p) (hL : L * p ≤ l) (hU : u ≤ U * q) : Encl (x / y) L U := by
  have hn : Encl (-x) (-u) (-l) := hx.neg le_rfl le_rfl
  have hm := hn.div_nonneg hy (neg_nonneg.2 hu) hp (L := -U) (U := -L)
    (by nlinarith only [hU]) (by nlinarith only [hL])
  simpa only [neg_div, neg_neg] using hm.neg le_rfl le_rfl

end CubicTorus.Arithmetic

namespace CubicTorus.Arithmetic
lemma Encl.pow {x l u L U : ℝ} (hx : Encl x l u) (hl : 0 ≤ l) (n : ℕ)
    (hL : L ≤ l ^ n) (hU : u ^ n ≤ U) : Encl (x ^ n) L U :=
  ⟨hL.trans (pow_le_pow_left₀ hl hx.1 n), (pow_le_pow_left₀ (hl.trans hx.1) hx.2 n).trans hU⟩
end CubicTorus.Arithmetic

noncomputable section
open Set MeasureTheory
open scoped ENNReal

namespace CubicTorus.Nesting

def lambda : ℝ := 49 / 50
def ell : ℝ := 7 / 25
def cutoff : ℝ := Real.sqrt 48 / 7
def rawWeight (X : ℝ) : ℝ := (1 - lambda * X ^ 2) / Real.sqrt (1 - X ^ 2)
def weight (X : ℝ) : ℝ := rawWeight (min X cutoff)

def fluxAux (J X : ℝ) : ℝ :=
  1 / X - lambda * X - J * (Real.sqrt (1 - X ^ 2) / X)

def fluxAuxDeriv (J X : ℝ) : ℝ :=
  -1 / X ^ 2 - lambda + J / (X ^ 2 * Real.sqrt (1 - X ^ 2))

def fluxAuxSecond (J X : ℝ) : ℝ :=
  2 / X ^ 3 + J * (3 * X ^ 2 - 2) /
    (X ^ 3 * (Real.sqrt (1 - X ^ 2)) ^ 3)

lemma sqrt_pos_of_mem_Ioo {x : ℝ} (hx : x ∈ Ioo 0 1) :
    0 < Real.sqrt (1 - x ^ 2) := by
  apply Real.sqrt_pos.2
  nlinarith [hx.1, hx.2, sq_nonneg x]

lemma sqrt_square_of_mem_Ioo {x : ℝ} (hx : x ∈ Ioo 0 1) :
    Real.sqrt (1 - x ^ 2) ^ 2 = 1 - x ^ 2 := by
  apply Real.sq_sqrt
  nlinarith [hx.1, hx.2, sq_nonneg x]

lemma hasDerivAt_sqrt_one_sub_sq {x : ℝ} (hx : x ∈ Ioo 0 1) :
    HasDerivAt (fun y : ℝ => Real.sqrt (1 - y ^ 2))
      (-x / Real.sqrt (1 - x ^ 2)) x := by
  have hp : 0 < 1 - x ^ 2 := by nlinarith [hx.1, hx.2, sq_nonneg x]
  convert ((hasDerivAt_const x (1 : ℝ)).sub ((hasDerivAt_id x).pow 2)).sqrt
    (ne_of_gt hp) using 1
  · rfl
  · dsimp
    ring

lemma hasDerivAt_fluxAux {J x : ℝ} (hx : x ∈ Ioo 0 1) :
    HasDerivAt (fluxAux J) (fluxAuxDeriv J x) x := by
  have hx0 : x ≠ 0 := ne_of_gt hx.1
  have hs0 : Real.sqrt (1 - x ^ 2) ≠ 0 := ne_of_gt (sqrt_pos_of_mem_Ioo hx)
  have hs2 := sqrt_square_of_mem_Ioo hx
  have hs := hasDerivAt_sqrt_one_sub_sq hx
  have hh := (((hasDerivAt_const x (1 : ℝ)).div (hasDerivAt_id x) hx0).sub
    ((hasDerivAt_id x).const_mul lambda)).sub
    ((hs.div (hasDerivAt_id x) hx0).const_mul J)
  convert hh using 1 <;> try rfl
  dsimp [fluxAuxDeriv]
  field_simp [hx0, hs0]
  linear_combination -J * hs2

lemma hasDerivAt_fluxAuxDeriv {J x : ℝ} (hx : x ∈ Ioo 0 1) :
    HasDerivAt (fluxAuxDeriv J) (fluxAuxSecond J x) x := by
  have hx0 : x ≠ 0 := ne_of_gt hx.1
  have hs0 : Real.sqrt (1 - x ^ 2) ≠ 0 := ne_of_gt (sqrt_pos_of_mem_Ioo hx)
  have hs2 := sqrt_square_of_mem_Ioo hx
  have hs := hasDerivAt_sqrt_one_sub_sq hx
  have hsq := (hasDerivAt_id x).pow 2
  have hh := (((hasDerivAt_const x (-1 : ℝ)).div hsq (pow_ne_zero 2 hx0)).sub
    (hasDerivAt_const x lambda)).add
    ((hasDerivAt_const x J).div (hsq.mul hs) (mul_ne_zero (pow_ne_zero 2 hx0) hs0))
  convert hh using 1 <;> try rfl
  dsimp [fluxAuxSecond]
  field_simp [hx0, hs0]
  linear_combination 2 * J * hs2

lemma fluxAuxSecond_nonneg {J x : ℝ} (hJ : J ∈ Icc 0 1) (hx : x ∈ Ioo 0 1) :
    0 ≤ fluxAuxSecond J x := by
  have hs : 0 < Real.sqrt (1 - x ^ 2) := sqrt_pos_of_mem_Ioo hx
  have hs2 := sqrt_square_of_mem_Ioo hx
  unfold fluxAuxSecond
  have hx0 := ne_of_gt hx.1
  have hs0 := ne_of_gt hs
  rw [show 2 / x ^ 3 + J * (3 * x ^ 2 - 2) /
      (x ^ 3 * Real.sqrt (1 - x ^ 2) ^ 3) =
      (2 * Real.sqrt (1 - x ^ 2) ^ 3 + J * (3 * x ^ 2 - 2)) /
      (x ^ 3 * Real.sqrt (1 - x ^ 2) ^ 3) by field_simp]
  apply div_nonneg _ (le_of_lt (mul_pos (pow_pos hx.1 _) (pow_pos hs _)))
  have hid : 2 * Real.sqrt (1 - x ^ 2) ^ 3 + J * (3 * x ^ 2 - 2) =
      (1 - J) * (2 * Real.sqrt (1 - x ^ 2) ^ 3) +
      J * ((Real.sqrt (1 - x ^ 2) - 1) ^ 2 * (2 * Real.sqrt (1 - x ^ 2) + 1)) := by
    linear_combination 3 * J * hs2
  rw [hid]
  exact add_nonneg (mul_nonneg (sub_nonneg.mpr hJ.2) (by positivity))
    (mul_nonneg hJ.1 (mul_nonneg (sq_nonneg _) (by positivity)))

lemma continuousOn_fluxAux {ε : ℝ} (hε : 0 < ε) (J : ℝ) :
    ContinuousOn (fluxAux J) (Icc ε 1) := by
  have hn : ∀ x ∈ Icc ε (1 : ℝ), x ≠ 0 := fun _ hx => ne_of_gt (lt_of_lt_of_le hε hx.1)
  have hc : Continuous (fun x : ℝ => Real.sqrt (1 - x ^ 2)) :=
    Real.continuous_sqrt.comp (continuous_const.sub (continuous_id.pow 2))
  exact ((continuousOn_const.div continuousOn_id hn).sub
    (continuousOn_const.mul continuousOn_id)).sub
    (continuousOn_const.mul (hc.continuousOn.div continuousOn_id hn))

lemma convexOn_fluxAux {ε J : ℝ} (hε : 0 < ε) (hJ : J ∈ Icc 0 1) :
    ConvexOn ℝ (Icc ε 1) (fluxAux J) := by
  refine convexOn_of_hasDerivWithinAt2_nonneg (f' := fluxAuxDeriv J)
    (f'' := fluxAuxSecond J) (convex_Icc ε 1) (continuousOn_fluxAux hε J) ?_ ?_ ?_
  · intro x hx
    rw [interior_Icc] at hx
    exact (hasDerivAt_fluxAux ⟨lt_trans hε hx.1, hx.2⟩).hasDerivWithinAt
  · intro x hx
    rw [interior_Icc] at hx
    exact (hasDerivAt_fluxAuxDeriv ⟨lt_trans hε hx.1, hx.2⟩).hasDerivWithinAt
  · intro x hx
    rw [interior_Icc] at hx
    exact fluxAuxSecond_nonneg hJ ⟨lt_trans hε hx.1, hx.2⟩

lemma cutoff_pos : 0 < cutoff := by
  unfold cutoff
  positivity

lemma cutoff_sq : cutoff ^ 2 = 48 / 49 := by
  norm_num [cutoff, div_pow]

lemma cutoff_lt_one : cutoff < 1 := by
  nlinarith [cutoff_sq, cutoff_pos]

lemma sqrt_cutoff : Real.sqrt (1 - cutoff ^ 2) = 1 / 7 := by
  rw [cutoff_sq]
  norm_num

lemma rawWeight_cutoff : rawWeight cutoff = ell := by
  rw [rawWeight, sqrt_cutoff, cutoff_sq]
  norm_num [lambda, ell]

lemma rawWeight_lower {x : ℝ} (hx : x ∈ Ico 0 1) : ell ≤ rawWeight x := by
  have hrad : 0 < 1 - x ^ 2 := by nlinarith [hx.1, hx.2, sq_nonneg x]
  have hs : 0 < Real.sqrt (1 - x ^ 2) := Real.sqrt_pos.2 hrad
  have hs2 := Real.sq_sqrt (le_of_lt hrad)
  unfold rawWeight ell lambda
  apply (le_div_iff₀ hs).2
  nlinarith [sq_nonneg (7 * Real.sqrt (1 - x ^ 2) - 1)]

lemma hasDerivAt_rawWeight {x : ℝ} (hx : x ∈ Ioo 0 1) :
    HasDerivAt rawWeight
      (x * (49 * x ^ 2 - 48) / (50 * Real.sqrt (1 - x ^ 2) ^ 3)) x := by
  have hs := hasDerivAt_sqrt_one_sub_sq hx
  have hs0 := ne_of_gt (sqrt_pos_of_mem_Ioo hx)
  have hs2 := sqrt_square_of_mem_Ioo hx
  have hh := ((hasDerivAt_const x (1 : ℝ)).sub
    (((hasDerivAt_id x).pow 2).const_mul lambda)).div hs hs0
  convert hh using 1 <;> try rfl
  dsimp [lambda]
  field_simp
  linear_combination 98 * x * hs2

lemma continuousOn_rawWeight : ContinuousOn rawWeight (Icc 0 cutoff) := by
  have hs : ∀ x ∈ Icc 0 cutoff, Real.sqrt (1 - x ^ 2) ≠ 0 := by
    intro x hx
    apply ne_of_gt (Real.sqrt_pos.2 _)
    have hxl : x < 1 := lt_of_le_of_lt hx.2 cutoff_lt_one
    nlinarith [hx.1, sq_nonneg x]
  exact (continuousOn_const.sub (continuousOn_const.mul (continuousOn_id.pow 2))).div
    ((Real.continuous_sqrt.comp (continuous_const.sub (continuous_id.pow 2))).continuousOn) hs

lemma antitoneOn_rawWeight : AntitoneOn rawWeight (Icc 0 cutoff) := by
  refine antitoneOn_of_hasDerivWithinAt_nonpos (f' := fun x =>
    x * (49 * x ^ 2 - 48) / (50 * Real.sqrt (1 - x ^ 2) ^ 3))
    (convex_Icc 0 cutoff) continuousOn_rawWeight ?_ ?_
  · intro x hx
    rw [interior_Icc] at hx
    exact (hasDerivAt_rawWeight ⟨hx.1, lt_trans hx.2 cutoff_lt_one⟩).hasDerivWithinAt
  · intro x hx
    rw [interior_Icc] at hx
    apply div_nonpos_of_nonpos_of_nonneg _ (by positivity)
    apply mul_nonpos_of_nonneg_of_nonpos (le_of_lt hx.1)
    have hsq : x ^ 2 ≤ cutoff ^ 2 :=
      pow_le_pow_left₀ (le_of_lt hx.1) (le_of_lt hx.2) 2
    nlinarith [cutoff_sq]

lemma weight_mem {x : ℝ} (hx : 0 ≤ x) : weight x ∈ Icc ell 1 := by
  have hm : min x cutoff ∈ Icc 0 cutoff :=
    ⟨le_min hx (le_of_lt cutoff_pos), min_le_right _ _⟩
  constructor
  · exact rawWeight_lower ⟨hm.1, lt_of_le_of_lt hm.2 cutoff_lt_one⟩
  · have hh := antitoneOn_rawWeight ⟨le_rfl, le_of_lt cutoff_pos⟩ hm hm.1
    simpa [weight, rawWeight] using hh

lemma antitoneOn_weight : AntitoneOn weight (Ici 0) := by
  intro x hx y hy hxy
  exact antitoneOn_rawWeight
    ⟨le_min hx (le_of_lt cutoff_pos), min_le_right _ _⟩
    ⟨le_min hy (le_of_lt cutoff_pos), min_le_right _ _⟩ (min_le_min hxy le_rfl)

lemma weight_le_rawWeight {x : ℝ} (hx : x ∈ Ico 0 1) : weight x ≤ rawWeight x := by
  by_cases hxc : x ≤ cutoff
  · simp [weight, min_eq_left hxc]
  · rw [weight, min_eq_right (le_of_not_ge hxc), rawWeight_cutoff]
    exact rawWeight_lower hx

lemma fluxAux_weight_nonneg {m : ℝ} (hm : m ∈ Ioc 0 1) :
    0 ≤ fluxAux (weight m) m := by
  rcases lt_or_eq_of_le hm.2 with hm1 | rfl
  · have hs : 0 < Real.sqrt (1 - m ^ 2) := sqrt_pos_of_mem_Ioo ⟨hm.1, hm1⟩
    have hw := weight_le_rawWeight ⟨le_of_lt hm.1, hm1⟩
    have hh : weight m * Real.sqrt (1 - m ^ 2) ≤ 1 - lambda * m ^ 2 :=
      (le_div_iff₀ hs).mp hw
    rw [fluxAux, show 1 / m - lambda * m - weight m * (Real.sqrt (1 - m ^ 2) / m) =
      (1 - lambda * m ^ 2 - weight m * Real.sqrt (1 - m ^ 2)) / m by
        field_simp]
    exact div_nonneg (sub_nonneg.mpr hh) (le_of_lt hm.1)
  · norm_num [fluxAux, lambda]

theorem integrated_flux_probability {Ω : Type*} [MeasurableSpace Ω]
    {μ : Measure Ω} [IsProbabilityMeasure μ] {α : Ω → ℝ} {ε : ℝ}
    (hε : 0 < ε) (hα : ∀ᵐ x ∂μ, α x ∈ Icc ε 1)
    (hαi : Integrable α μ) (hii : Integrable (fun x => 1 / α x) μ)
    (hqi : Integrable (fun x => Real.sqrt (1 - α x ^ 2) / α x) μ) :
    weight (∫ x, α x ∂μ) * (∫ x, Real.sqrt (1 - α x ^ 2) / α x ∂μ) ≤
      (∫ x, 1 / α x ∂μ) - lambda * (∫ x, α x ∂μ) := by
  let m : ℝ := ∫ x, α x ∂μ
  have hm : m ∈ Icc ε 1 := by
    constructor
    · have hh := integral_mono_ae (integrable_const ε) hαi (hα.mono fun _ hx => hx.1)
      simpa [m] using hh
    · have hh := integral_mono_ae hαi (integrable_const (1 : ℝ)) (hα.mono fun _ hx => hx.2)
      simpa [m] using hh
  have hm0 : 0 < m := lt_of_lt_of_le hε hm.1
  have hw := weight_mem (le_of_lt hm0)
  have hJ : weight m ∈ Icc 0 1 := ⟨le_trans (by norm_num [ell]) hw.1, hw.2⟩
  have hfi : Integrable ((fluxAux (weight m)) ∘ α) μ :=
    (hii.sub (hαi.const_mul lambda)).sub (hqi.const_mul (weight m))
  have hj := (convexOn_fluxAux hε hJ).map_integral_le
    (continuousOn_fluxAux hε (weight m)) isClosed_Icc hα hαi hfi
  have hh : 0 ≤ ∫ x, fluxAux (weight m) (α x) ∂μ :=
    (fluxAux_weight_nonneg ⟨hm0, hm.2⟩).trans hj
  change 0 ≤ ∫ x, ((1 / α x - lambda * α x) -
    weight m * (Real.sqrt (1 - α x ^ 2) / α x)) ∂μ at hh
  have hli : Integrable (fun x => 1 / α x - lambda * α x) μ :=
    hii.sub (hαi.const_mul lambda)
  rw [integral_sub hli (hqi.const_mul (weight m)),
    integral_sub hii (hαi.const_mul lambda), integral_const_mul, integral_const_mul] at hh
  exact sub_nonneg.mp hh

lemma product_sqrt_le_half {x : ℝ} (hx : x ∈ Icc 0 1) :
    x * Real.sqrt (1 - x ^ 2) ≤ 1 / 2 := by
  have hr : 0 ≤ 1 - x ^ 2 := by nlinarith [hx.1, hx.2]
  nlinarith [Real.sq_sqrt hr, sq_nonneg (x - Real.sqrt (1 - x ^ 2))]

lemma product_sqrt_le_of_lower {a x d : ℝ} (ha : 0 ≤ a) (hax : a ≤ x)
    (hx1 : x ≤ 1) (ha2 : 1 / 2 ≤ a ^ 2) (hd : 0 ≤ d)
    (had : a ^ 2 * (1 - a ^ 2) ≤ d ^ 2) :
    x * Real.sqrt (1 - x ^ 2) ≤ d := by
  have hx0 := le_trans ha hax
  have hxa := pow_le_pow_left₀ ha hax 2
  have hr : 0 ≤ 1 - x ^ 2 := by nlinarith
  have hs := Real.sq_sqrt hr
  have hxs := congrArg (fun t : ℝ => x ^ 2 * t) hs
  have hp : (x ^ 2 - a ^ 2) * (1 - a ^ 2 - x ^ 2) ≤ 0 :=
    mul_nonpos_of_nonneg_of_nonpos (by linarith) (by nlinarith)
  apply (sq_le_sq₀ (mul_nonneg hx0 (Real.sqrt_nonneg _)) hd).1
  nlinarith

lemma weight_derivative_bound_of_row {x n d : ℝ} (hx : x ∈ Ico 0 1)
    (hn : n * (1 - x ^ 2) ≤ 48 / 100 - (49 / 100 : ℝ) * x ^ 2)
    (hd : x * Real.sqrt (1 - x ^ 2) ≤ d) (hnd : (91 / 100 : ℝ) * d ≤ n) :
    (91 / 100 : ℝ) * x ≤
      (48 / 100 - (49 / 100 : ℝ) * x ^ 2) / Real.sqrt (1 - x ^ 2) ^ 3 := by
  have hr : 0 < 1 - x ^ 2 := by nlinarith [hx.1, hx.2]
  have hs : 0 < Real.sqrt (1 - x ^ 2) := Real.sqrt_pos.2 hr
  apply (le_div_iff₀ (pow_pos hs 3)).2
  calc
    (91 / 100 : ℝ) * x * Real.sqrt (1 - x ^ 2) ^ 3 =
        ((91 / 100 : ℝ) * (x * Real.sqrt (1 - x ^ 2))) * Real.sqrt (1 - x ^ 2) ^ 2 := by ring
    _ ≤ ((91 / 100 : ℝ) * d) * Real.sqrt (1 - x ^ 2) ^ 2 :=
      mul_le_mul_of_nonneg_right (mul_le_mul_of_nonneg_left hd (by norm_num)) (sq_nonneg _)
    _ ≤ n * Real.sqrt (1 - x ^ 2) ^ 2 := mul_le_mul_of_nonneg_right hnd (sq_nonneg _)
    _ = n * (1 - x ^ 2) := by rw [Real.sq_sqrt (le_of_lt hr)]
    _ ≤ 48 / 100 - (49 / 100 : ℝ) * x ^ 2 := hn

theorem weight_derivative_bound {x : ℝ} (hx : x ∈ Icc 0 (24 / 25 : ℝ)) :
    (91 / 100 : ℝ) * x ≤
      (48 / 100 - (49 / 100 : ℝ) * x ^ 2) / Real.sqrt (1 - x ^ 2) ^ 3 := by
  have hx1 : x ∈ Ico 0 1 := ⟨hx.1, by linarith [hx.2]⟩
  by_cases h84 : x ≤ 84 / 100
  · have hsq := pow_le_pow_left₀ hx.1 h84 2
    apply weight_derivative_bound_of_row (n := 456 / 1000) (d := 1 / 2) hx1
    · nlinarith
    · exact product_sqrt_le_half ⟨hx.1, le_of_lt hx1.2⟩
    · norm_num
  by_cases h89 : x ≤ 89 / 100
  · have hsq := pow_le_pow_left₀ hx.1 h89 2
    apply weight_derivative_bound_of_row (n := 44 / 100) (d := 46 / 100) hx1
    · nlinarith
    · apply product_sqrt_le_of_lower (a := 84 / 100) (by norm_num) (le_of_not_ge h84)
        (le_of_lt hx1.2) <;> norm_num
    · norm_num
  by_cases h94 : x ≤ 94 / 100
  · have hsq := pow_le_pow_left₀ hx.1 h94 2
    apply weight_derivative_bound_of_row (n := 40 / 100) (d := 41 / 100) hx1
    · nlinarith
    · apply product_sqrt_le_of_lower (a := 89 / 100) (by norm_num) (le_of_not_ge h89)
        (le_of_lt hx1.2) <;> norm_num
    · norm_num
  · have hsq := pow_le_pow_left₀ hx.1 hx.2 2
    apply weight_derivative_bound_of_row (n := 36 / 100) (d := 33 / 100) hx1
    · nlinarith
    · apply product_sqrt_le_of_lower (a := 94 / 100) (by norm_num) (le_of_not_ge h94)
        (le_of_lt hx1.2) <;> norm_num
    · norm_num

def squaredWeight (r : ℝ) : ℝ := (1 - lambda * r) / Real.sqrt (1 - r)

lemma hasDerivAt_squaredWeight {r : ℝ} (hr : r < 1) :
    HasDerivAt squaredWeight
      (-((48 / 100 - (49 / 100 : ℝ) * r) / Real.sqrt (1 - r) ^ 3)) r := by
  have hrad : 0 < 1 - r := sub_pos.2 hr
  have hs := ((hasDerivAt_const r (1 : ℝ)).sub (hasDerivAt_id r)).sqrt (ne_of_gt hrad)
  have hs2 := Real.sq_sqrt (le_of_lt hrad)
  have hs0 := ne_of_gt (Real.sqrt_pos.2 hrad)
  have hh := ((hasDerivAt_const r (1 : ℝ)).sub
    ((hasDerivAt_id r).const_mul lambda)).div hs hs0
  convert hh using 1 <;> try rfl
  dsimp [lambda]
  field_simp
  linear_combination 9800 * hs2

lemma squaredWeight_eq_rawWeight {r : ℝ} (hr : 0 ≤ r) :
    squaredWeight r = rawWeight (Real.sqrt r) := by
  simp only [squaredWeight, rawWeight, Real.sq_sqrt hr]

lemma squaredWeight_difference {a b : ℝ} (ha : 0 ≤ a) (hab : a ≤ b)
    (hb : b ≤ (24 / 25 : ℝ) ^ 2) :
    (91 / 100 : ℝ) * Real.sqrt a * (b - a) ≤ squaredWeight a - squaredWeight b := by
  have hi : ∀ r ∈ Icc a b, 0 ≤ r ∧ r < 1 := fun r hr => ⟨le_trans ha hr.1, by linarith [hr.2]⟩
  have hc : ContinuousOn squaredWeight (Icc a b) := by
    intro r hr
    exact (hasDerivAt_squaredWeight (hi r hr).2).continuousAt.continuousWithinAt
  have hm : AntitoneOn (fun r => squaredWeight r + (91 / 100 : ℝ) * Real.sqrt a * r) (Icc a b) := by
    apply antitoneOn_of_hasDerivWithinAt_nonpos (f' := fun r =>
      -((48 / 100 - (49 / 100 : ℝ) * r) / Real.sqrt (1 - r) ^ 3) +
        (91 / 100 : ℝ) * Real.sqrt a) (convex_Icc a b)
    · exact hc.add (continuousOn_const.mul continuousOn_id)
    · intro r hr
      rw [interior_Icc] at hr
      convert ((hasDerivAt_squaredWeight (hi r ⟨le_of_lt hr.1, le_of_lt hr.2⟩).2).add
        ((hasDerivAt_id r).const_mul ((91 / 100 : ℝ) * Real.sqrt a))).hasDerivWithinAt using 1 <;> try rfl
      simp only [mul_one]
    · intro r hr
      rw [interior_Icc] at hr
      have hr0 := le_trans ha (le_of_lt hr.1)
      have hs : Real.sqrt r ∈ Icc 0 (24 / 25 : ℝ) :=
        ⟨Real.sqrt_nonneg _, Real.sqrt_le_iff.2 ⟨by norm_num, le_trans (le_of_lt hr.2) hb⟩⟩
      have hbound := weight_derivative_bound hs
      rw [Real.sq_sqrt hr0] at hbound
      have hmon := Real.sqrt_le_sqrt (le_of_lt hr.1)
      linarith
  have hh := hm ⟨le_refl a, hab⟩ ⟨hab, le_refl b⟩ hab
  linarith

theorem pointwise_weight_gain {x K : ℝ} (hx : x ∈ Icc 0 (24 / 25 : ℝ)) (hK : 0 ≤ K) :
    (91 / 100 : ℝ) * x ^ 3 * K / Real.sqrt (1 + K) ^ 3 ≤
      weight (x / Real.sqrt (1 + K)) - weight x := by
  have hp : 0 < 1 + K := by linarith
  have hs0 : 0 < Real.sqrt (1 + K) := Real.sqrt_pos.2 hp
  have hs1 : 1 ≤ Real.sqrt (1 + K) := by
    nlinarith [Real.sq_sqrt (le_of_lt hp), Real.sqrt_nonneg (1 + K)]
  have hy0 : 0 ≤ x / Real.sqrt (1 + K) := div_nonneg hx.1 (le_of_lt hs0)
  have hyx : x / Real.sqrt (1 + K) ≤ x := (div_le_iff₀ hs0).2 (by nlinarith [hx.1])
  have hd : (24 / 25 : ℝ) < cutoff := by nlinarith [cutoff_sq, cutoff_pos]
  have hc1 : x ≤ cutoff := le_trans hx.2 (le_of_lt hd)
  have hc2 : x / Real.sqrt (1 + K) ≤ cutoff := le_trans hyx hc1
  rw [weight, min_eq_left hc2, weight, min_eq_left hc1]
  have ha : 0 ≤ x ^ 2 / (1 + K) := div_nonneg (sq_nonneg x) (le_of_lt hp)
  have hab : x ^ 2 / (1 + K) ≤ x ^ 2 := (div_le_iff₀ hp).2 (by nlinarith [sq_nonneg x])
  have hb := pow_le_pow_left₀ hx.1 hx.2 2
  have hg := squaredWeight_difference ha hab hb
  have heqa : Real.sqrt (x ^ 2 / (1 + K)) = x / Real.sqrt (1 + K) := by
    rw [Real.sqrt_div (sq_nonneg x), Real.sqrt_sq hx.1]
  rw [squaredWeight_eq_rawWeight ha, squaredWeight_eq_rawWeight (sq_nonneg x),
    heqa, Real.sqrt_sq hx.1] at hg
  convert hg using 1
  have hs2 := Real.sq_sqrt (le_of_lt hp)
  field_simp
  linear_combination -x ^ 3 * K * hs2

end CubicTorus.Nesting

noncomputable section
open Set MeasureTheory
open scoped Interval

namespace CubicTorus.Shape

def t (h : ℝ) : ℝ := 2 / (1 + Real.sqrt (1 + 4 * h ^ 2 / Real.pi))
def c : ℝ := 27 / 10
def dm : ℝ := 21 / 100
def u (h : ℝ) : ℝ := min (1 - 1 / Real.pi) ((24 / 25 : ℝ) / h)
def theta : ℝ := 2 / (1 + Real.sqrt (1 + 4 * c * dm / Real.pi))
def shape (q : ℝ) : ℝ := min (q ^ 2) (Real.pi * (1 - q) / (c * dm))
def moment : ℝ := ∫ q in (0 : ℝ)..1, shape q
def firstMoment : ℝ := ∫ q in (0 : ℝ)..1, q * shape q
def meanQ : ℝ := firstMoment / moment
def p₂ : ℝ := 1 + c * dm ^ 2 * theta ^ 2

lemma positive_quadratic_root {a : ℝ} (ha : 0 < a) :
    let r := 2 / (1 + Real.sqrt (1 + 4 * a / Real.pi))
    0 < r ∧ r < 1 ∧ a * r ^ 2 = Real.pi * (1 - r) := by
  have hp := Real.pi_pos
  have hr : 1 < 1 + 4 * a / Real.pi := by
    have : 0 < 4 * a / Real.pi := by positivity
    linarith
  have hs0 := Real.sqrt_nonneg (1 + 4 * a / Real.pi)
  have hs := Real.sq_sqrt (by linarith : 0 ≤ 1 + 4 * a / Real.pi)
  have hs1 : 1 < Real.sqrt (1 + 4 * a / Real.pi) := by nlinarith
  have hd : 0 < 1 + Real.sqrt (1 + 4 * a / Real.pi) := by linarith
  refine ⟨div_pos (by norm_num) hd, (div_lt_one hd).2 (by linarith), ?_⟩
  generalize hz : Real.sqrt (1 + 4 * a / Real.pi) = z at *
  field_simp at hs ⊢
  nlinarith

lemma t_spec {h : ℝ} (hh : 0 < h) :
    0 < t h ∧ t h < 1 ∧ h ^ 2 * t h ^ 2 = Real.pi * (1 - t h) := by
  exact positive_quadratic_root (sq_pos_of_pos hh)

lemma extent_lower_bound {h s L : ℝ} (hL : 0 < L)
    (hcal : (1 - s) / L + Real.pi * L / 4 ≤ h * s) :
    2 / Real.pi * (h * s - Real.sqrt (h ^ 2 * s ^ 2 - Real.pi * (1 - s))) ≤ L := by
  have hp := Real.pi_pos
  have hh := (mul_le_mul_of_nonneg_right hcal (le_of_lt hL))
  have hsq : (h * s - Real.pi * L / 2) ^ 2 ≤ h ^ 2 * s ^ 2 - Real.pi * (1 - s) := by
    have heq : ((1 - s) / L + Real.pi * L / 4) * L = 1 - s + Real.pi * L ^ 2 / 4 := by
      field_simp
    rw [heq] at hh
    have hm := mul_le_mul_of_nonneg_left hh (le_of_lt hp)
    nlinarith
  have hs := Real.le_sqrt_of_sq_le hsq
  convert (show 2 * (h * s - Real.sqrt (h ^ 2 * s ^ 2 - Real.pi * (1 - s))) / Real.pi ≤ L from
    (div_le_iff₀ hp).2 (by nlinarith)) using 1
  ring

lemma endpoint_slack_bound {h s t₀ : ℝ} (hh : 0 ≤ h) (ht : 0 ≤ t₀) (hst : t₀ ≤ s)
    (hroot : h ^ 2 * t₀ ^ 2 = Real.pi * (1 - t₀)) :
    1 - 2 / Real.pi * (h * s - Real.sqrt (h ^ 2 * s ^ 2 - Real.pi * (1 - s))) ≤
      1 - 2 * h * t₀ / Real.pi +
        (2 / Real.pi * Real.sqrt (Real.pi + 2 * h ^ 2 * t₀)) * Real.sqrt (s - t₀) := by
  let Y := Real.sqrt (s - t₀)
  let R := Real.sqrt (Real.pi + 2 * h ^ 2 * t₀)
  have hY : 0 ≤ Y := Real.sqrt_nonneg _
  have hY2 : Y ^ 2 = s - t₀ := Real.sq_sqrt (sub_nonneg.2 hst)
  have hR : 0 ≤ R := Real.sqrt_nonneg _
  have hR2 : R ^ 2 = Real.pi + 2 * h ^ 2 * t₀ := Real.sq_sqrt (by positivity)
  have hupper : Real.sqrt (h ^ 2 * s ^ 2 - Real.pi * (1 - s)) ≤ R * Y + h * Y ^ 2 := by
    apply Real.sqrt_le_iff.2
    refine ⟨by positivity, ?_⟩
    have hm : 0 ≤ 2 * (R * Y) * (h * Y ^ 2) := by positivity
    have heq : h ^ 2 * s ^ 2 - Real.pi * (1 - s) = R ^ 2 * Y ^ 2 + h ^ 2 * Y ^ 4 := by
      rw [hR2]
      have hs : s = t₀ + Y ^ 2 := by linarith
      rw [hs]
      nlinarith [hroot]
    rw [heq]
    nlinarith
  have hm := mul_le_mul_of_nonneg_left hupper (le_of_lt (div_pos (by norm_num : (0 : ℝ) < 2) Real.pi_pos))
  dsimp [R, Y] at hm hY2
  rw [hY2] at hm
  ring_nf at hm ⊢
  linarith only [hm]

theorem interval_placement {h : ℝ} (hh : h ∈ Icc (51 / 50 : ℝ) (81 / 50 : ℝ)) :
    (1033 / 2700 : ℝ) ≤ u h - dm ∧ (38 / 100 : ℝ) < u h - dm ∧
    1 / Real.pi < (38 / 100 : ℝ) ∧ u h ≤ 1 - 1 / Real.pi ∧
    u h < t h ∧ h * u h ≤ 24 / 25 := by
  have hp := Real.pi_pos
  have hp3 := Real.pi_gt_three
  have hh0 : 0 < h := by linarith [hh.1]
  have hu1 : u h ≤ 1 - 1 / Real.pi := min_le_left _ _
  have huv : u h ≤ (24 / 25 : ℝ) / h := min_le_right _ _
  have hu : (16 / 27 : ℝ) ≤ u h := by
    apply le_min
    · apply (le_sub_iff_add_le).2
      have hip : 1 / Real.pi ≤ (1 / 3 : ℝ) := (div_le_div_of_nonneg_left (by norm_num) (by norm_num) (le_of_lt hp3))
      linarith
    · apply (le_div_iff₀ hh0).2
      linarith [hh.2]
  have hhU : h * u h ≤ 24 / 25 := by
    have := (le_div_iff₀ hh0).1 huv
    nlinarith
  have htr := t_spec hh0
  have hlt : u h < t h := by
    by_contra! hn
    have hm := mul_le_mul_of_nonneg_left (pow_le_pow_left₀ (le_of_lt htr.1) hn 2) (sq_nonneg h)
    have hsq := pow_le_pow_left₀ (mul_nonneg (le_of_lt hh0) (by linarith : 0 ≤ u h)) hhU 2
    have hip : 1 ≤ Real.pi * (1 - u h) := by
      have hh := mul_le_mul_of_nonneg_left hu1 (le_of_lt hp)
      field_simp at hh
      nlinarith
    nlinarith [htr.2.2]
  refine ⟨?_, ?_, ?_, hu1, hlt, hhU⟩
  · dsimp [dm]; linarith
  · dsimp [dm]; linarith
  · apply (div_lt_iff₀ hp).2
    nlinarith

lemma theta_spec : 0 < theta ∧ theta < 1 ∧ c * dm * theta ^ 2 = Real.pi * (1 - theta) := by
  simpa only [theta, mul_assoc] using positive_quadratic_root (a := c * dm) (by norm_num [c, dm])

lemma theta_bounds : (32 / 37 : ℝ) < theta ∧ theta < 13 / 15 := by
  have ht := theta_spec
  have hp := Real.pi_gt_d2
  have hpU : Real.pi < (22 / 7 : ℝ) := by linarith [Real.pi_lt_d4]
  have hr := ht.2.2
  norm_num [c, dm] at hr
  constructor
  · by_contra! hn
    have hs := pow_le_pow_left₀ (le_of_lt ht.1) hn 2
    have hh := mul_lt_mul_of_pos_right hp (by linarith : 0 < 1 - theta)
    nlinarith
  · by_contra! hn
    have hs := pow_le_pow_left₀ (by norm_num : (0 : ℝ) ≤ 13 / 15) hn 2
    have hh := mul_lt_mul_of_pos_right hpU (by linarith : 0 < 1 - theta)
    nlinarith

lemma shape_on_left {q : ℝ} (hq : q ∈ Icc 0 theta) : shape q = q ^ 2 := by
  apply min_eq_left
  apply (le_div_iff₀ (by norm_num [c, dm] : 0 < c * dm)).2
  have hm := mul_le_mul_of_nonneg_left (pow_le_pow_left₀ hq.1 hq.2 2)
    (by norm_num [c, dm] : 0 ≤ c * dm)
  have ht := theta_spec.2.2
  have hp := mul_le_mul_of_nonneg_left hq.2 (le_of_lt Real.pi_pos)
  nlinarith

lemma shape_on_right {q : ℝ} (hq : q ∈ Icc theta 1) :
    shape q = Real.pi * (1 - q) / (c * dm) := by
  apply min_eq_right
  apply (div_le_iff₀ (by norm_num [c, dm] : 0 < c * dm)).2
  have hm := mul_le_mul_of_nonneg_left (pow_le_pow_left₀ (le_of_lt theta_spec.1) hq.1 2)
    (by norm_num [c, dm] : 0 ≤ c * dm)
  have ht := theta_spec.2.2
  have hp := mul_le_mul_of_nonneg_left hq.1 (le_of_lt Real.pi_pos)
  nlinarith

end CubicTorus.Shape
end
end
end
end ReusedScalar205
end
end

end OAI