import Mathlib
import OAI.Geometry.CubicTorus.Reflection.AxialAreaDensity

namespace OAI

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

theorem isMinimizerAt_section_complement_both_extents {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) (t : ℝ)
    (hout : quotientMap (axialSectionCorner b i t (fun _ ↦ true))∉closure (openRepresentative E))
    (hin0 : quotientMap (axialSectionCorner b i t (fun j ↦ j==0))∈openRepresentative E)
    (hin1 : quotientMap (axialSectionCorner b i t (fun j ↦ j==1))∈openRepresentative E)
    (hn : volume (axialSlice (frontier (openRepresentative E)) i (t : AxisCircle))=0)
    (j : Fin 2) :
    ∃ L : ℝ,L∈Ioo 0 (1/2) ∧
      (∀ y∈centeredAxialSlice (openRepresentative Eᶜ) (fun k ↦ !b k) i (t : AxisCircle),‖y j‖<L) ∧
      (∀ y : TransverseProduct,(∀ k : Fin 2,k≠j →y k=0) →‖y j‖<L →
        y∈centeredAxialSlice (openRepresentative Eᶜ) (fun k ↦ !b k) i (t : AxisCircle)) ∧
      ENNReal.ofReal ((1-volume.real (axialSlice (openRepresentative E) i (t : AxisCircle)))/L+Real.pi*L)≤
        planarTorusPerimeter (axialSlice (openRepresentative E) i (t : AxisCircle)) := by
  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
  have hdc := isMinimizerAt_complement_octant_downset hV hmin hR hd
  have hswap0 : (fun j : Fin 2 ↦ !(j==0))=(fun j ↦ j==1) := by funext j; fin_cases j <;> decide
  have hswap1 : (fun j : Fin 2 ↦ !(j==1))=(fun j ↦ j==0) := by funext j; fin_cases j <;> decide
  have hin : quotientMap (axialSectionCorner (fun k ↦ !b k) i t (fun _ ↦ false))∈openRepresentative Eᶜ := by
    rw [openRepresentative_compl_eq hV hmin,axialSectionCorner_reverse]
    exact hout
  have hv0 : quotientMap (axialSectionCorner (fun k ↦ !b k) i t (fun j ↦ j==0))∉closure (openRepresentative Eᶜ) := by
    rw [closure_openRepresentative_compl_eq hV hmin,axialSectionCorner_reverse,hswap0]
    simpa using hin1
  have hv1 : quotientMap (axialSectionCorner (fun k ↦ !b k) i t (fun j ↦ j==1))∉closure (openRepresentative Eᶜ) := by
    rw [closure_openRepresentative_compl_eq hV hmin,axialSectionCorner_reverse,hswap1]
    simpa using hin0
  obtain ⟨L,hL,hband,hfill,hp⟩ := isMinimizerAt_section_both_extents hVc hmc hRc hdc i t hin hv0 hv1 j
  rw [axialSlice_complement_volume hV hmin i _ hn,axialSlice_complement_perimeter hV hmin i _ hn] at hp
  exact ⟨L,hL,hband,hfill,hp⟩

end CubicTorus

end
end

section

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

theorem isMinimizerAt_bottom_both_extents {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 : ℝ}
    (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) (ha : (axialAreaMarginal μ i : Measure AxisCircle)≪volume)
    (hv : quotientMap (orientedUpperVertex b (fun j ↦ if j=i then true else false))∉openRepresentative E)
    (hout : quotientMap (axialSectionCorner b i (octantHeight b i 0) (fun _ ↦ true))∉closure (openRepresentative E))
    (hin0 : quotientMap (axialSectionCorner b i (octantHeight b i 0) (fun j ↦ j==0))∈openRepresentative E)
    (hin1 : quotientMap (axialSectionCorner b i (octantHeight b i 0) (fun j ↦ j==1))∈openRepresentative E) :
    let s := volume.real (axialSlice (openRepresentative E) i (octantHeight b i 0 : AxisCircle))
    0<H*s ∧ Real.pi*(1-s)≤((H/2)*s)^2 ∧
      ∀ j : Fin 2,∃ L : ℝ,L∈Ioo 0 1 ∧
        (∀ y∈centeredAxialSlice (openRepresentative Eᶜ) (fun k ↦ !b k) i (octantHeight b i 0 : AxisCircle),2*‖y j‖<L) ∧
        (∀ y : TransverseProduct,(∀ k : Fin 2,k≠j →y k=0) →2*‖y j‖<L →
          y∈centeredAxialSlice (openRepresentative Eᶜ) (fun k ↦ !b k) i (octantHeight b i 0 : AxisCircle)) ∧
        (1-s)/L+Real.pi*L/4≤(H/2)*s := by
  dsimp only
  let s := volume.real (axialSlice (openRepresentative E) i (octantHeight b i 0 : AxisCircle))
  obtain ⟨hHs,hdisc,_⟩ := isMinimizerAt_bottom_extent_calibration hV hE hmin hR b hd hμ hCMC i ha hv hout hin0 hin1
  refine ⟨hHs,hdisc,fun j ↦ ?_⟩
  have hn := isMinimizerAt_boundary_slice_null hV hE hmin hμ i ha (octantHeight b i 0 : AxisCircle)
  obtain ⟨L,hL,hband,hfill,hcal⟩ := isMinimizerAt_section_complement_both_extents hV hmin hR hd i (octantHeight b i 0) hout hin0 hin1 hn j
  have hp := isMinimizerAt_missing_neighbor_seam_bound hV hE hmin hR b hd hμ hCMC i ha hv
  have hcal' : (1-s)/L+Real.pi*L≤H*s :=
    (ENNReal.ofReal_le_ofReal_iff hHs.le).mp (hcal.trans hp)
  refine ⟨2*L,⟨mul_pos (by norm_num) hL.1,by linarith [hL.2]⟩,?_,?_,?_⟩
  · intro y hy
    linarith [hband y hy]
  · intro y hy hyL
    exact hfill y hy (by linarith)
  · have he : (1-s)/(2*L)+Real.pi*(2*L)/4=((1-s)/L+Real.pi*L)/2 := by field_simp; ring
    rw [he]
    nlinarith [hcal']

end CubicTorus

end
end

section

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

lemma shape_nonneg {q : ℝ} (hq : q ∈ Icc 0 1) : 0 ≤ shape q := by
  exact le_min (sq_nonneg q) (div_nonneg
    (mul_nonneg (le_of_lt Real.pi_pos) (sub_nonneg.2 hq.2)) (by norm_num [c, dm]))

lemma shape_le_one {q : ℝ} (hq : q ∈ Icc 0 1) : shape q ≤ 1 := by
  have hq2 := pow_le_pow_left₀ hq.1 hq.2 2
  exact le_trans (min_le_left _ _) (by simpa using hq2)

lemma shape_max {q : ℝ} (hq : q ∈ Icc 0 1) : shape q ≤ theta ^ 2 := by
  by_cases hh : q ≤ theta
  · rw [shape_on_left ⟨hq.1, hh⟩]
    exact pow_le_pow_left₀ hq.1 hh 2
  · rw [shape_on_right ⟨le_of_not_ge hh, hq.2⟩]
    apply (div_le_iff₀ (by norm_num [c, dm] : 0 < c * dm)).2
    have ht := theta_spec.2.2
    have hp := mul_le_mul_of_nonneg_left (le_of_not_ge hh) (le_of_lt Real.pi_pos)
    nlinarith

lemma continuous_shape : Continuous shape := by
  unfold shape
  fun_prop

lemma integral_eq_split : moment = theta ^ 3 / 3 +
    Real.pi / (c * dm) * (1 - theta) ^ 2 / 2 := by
  have hfi : IntervalIntegrable shape volume 0 theta := continuous_shape.intervalIntegrable 0 theta
  have hfi2 : IntervalIntegrable shape volume theta 1 := continuous_shape.intervalIntegrable theta 1
  have h0 := theta_spec
  unfold moment
  rw [← intervalIntegral.integral_add_adjacent_intervals hfi hfi2]
  have hleft : (∫ q in (0 : ℝ)..theta, shape q) = theta ^ 3 / 3 := by
    rw [intervalIntegral.integral_congr (g := fun q : ℝ => q ^ 2) ?_]
    · norm_num
    · intro q hq
      rw [uIcc_of_le (le_of_lt h0.1)] at hq
      exact shape_on_left hq
  have hright : (∫ q in theta..(1 : ℝ), shape q) =
      Real.pi / (c * dm) * (1 - theta) ^ 2 / 2 := by
    rw [intervalIntegral.integral_congr (g := fun q : ℝ => Real.pi / (c * dm) * (1 - q)) ?_]
    · rw [intervalIntegral.integral_const_mul,
        intervalIntegral.integral_sub
          (show IntervalIntegrable (fun _ : ℝ => (1 : ℝ)) volume theta 1 from continuous_const.intervalIntegrable _ _)
          (show IntervalIntegrable (fun q : ℝ => q) volume theta 1 from continuous_id.intervalIntegrable _ _)]
      norm_num
      ring
    · intro q hq
      rw [uIcc_of_le (le_of_lt h0.2.1)] at hq
      dsimp only
      rw [shape_on_right hq]
      ring
  rw [hleft, hright]

lemma moment_eq : moment = theta ^ 2 * (3 - theta) / 6 := by
  rw [integral_eq_split]
  have ht := theta_spec.2.2
  norm_num [c, dm] at ht ⊢
  linear_combination -(500 / 567 : ℝ) * (1 - theta) * ht

lemma firstMoment_eq : firstMoment = theta ^ 2 * (2 + 2 * theta - theta ^ 2) / 12 := by
  have hc : Continuous (fun q : ℝ => q * shape q) := continuous_id.mul continuous_shape
  have h0 := theta_spec
  unfold firstMoment
  rw [← intervalIntegral.integral_add_adjacent_intervals
    (hc.intervalIntegrable (0 : ℝ) theta) (hc.intervalIntegrable theta (1 : ℝ))]
  have hl : (∫ q in (0 : ℝ)..theta, q * shape q) = theta ^ 4 / 4 := by
    rw [intervalIntegral.integral_congr (g := fun q : ℝ => q ^ 3) ?_]
    · norm_num
    · intro q hq
      rw [uIcc_of_le (le_of_lt h0.1)] at hq
      dsimp only
      rw [shape_on_left hq]
      ring
  have hr : (∫ q in theta..(1 : ℝ), q * shape q) =
      Real.pi / (c * dm) * ((1 - theta ^ 2) / 2 - (1 - theta ^ 3) / 3) := by
    rw [intervalIntegral.integral_congr (g := fun q : ℝ => Real.pi / (c * dm) * (q - q ^ 2)) ?_]
    · rw [intervalIntegral.integral_const_mul,
        intervalIntegral.integral_sub
          (show IntervalIntegrable (fun q : ℝ => q) volume theta 1 from continuous_id.intervalIntegrable _ _)
          (show IntervalIntegrable (fun q : ℝ => q ^ 2) volume theta 1 from (continuous_id.pow 2).intervalIntegrable _ _)]
      norm_num
    · intro q hq
      rw [uIcc_of_le (le_of_lt h0.2.1)] at hq
      dsimp only
      rw [shape_on_right hq]
      ring
  rw [hl, hr]
  have ht := h0.2.2
  norm_num [c, dm] at ht ⊢
  linear_combination -(500 / 1701 : ℝ) * (1 - theta) * (1 + 2 * theta) * ht

lemma moment_pos : 0 < moment := by
  rw [moment_eq]
  have ht := theta_spec
  have h3 : 0 < 3 - theta := by linarith [ht.2.1]
  have htpos := ht.1
  positivity

lemma meanQ_eq : meanQ = (2 + 2 * theta - theta ^ 2) / (2 * (3 - theta)) := by
  unfold meanQ
  rw [moment_eq, firstMoment_eq]
  have ht := theta_spec
  have ht0 := ne_of_gt ht.1
  have h30 : 3 - theta ≠ 0 := by linarith [ht.2.1]
  field_simp [ht0, h30]
  ring

lemma meanQ_mem : meanQ ∈ Ioo 0 1 := by
  rw [meanQ_eq]
  have ht := theta_spec
  have hs : theta ^ 2 < 1 := by nlinarith [ht.1, ht.2.1]
  constructor
  · apply div_pos
    · nlinarith
    · linarith
  · apply (div_lt_one (by linarith : 0 < 2 * (3 - theta))).2
    nlinarith [sq_nonneg (theta - 2)]

theorem moment_bounds : (2659 / 10000 : ℝ) < moment ∧
    (697 / 1000 : ℝ) < meanQ ∧ p₂ < (109 / 100 : ℝ) := by
  have ht := theta_spec
  have hb := theta_bounds
  have hθ2 := pow_lt_pow_left₀ hb.1 (by norm_num : (0 : ℝ) ≤ 32 / 37) (by norm_num : (2 : ℕ) ≠ 0)
  have hθU := pow_lt_pow_left₀ hb.2 (le_of_lt ht.1) (by norm_num : (2 : ℕ) ≠ 0)
  refine ⟨?_, ?_, ?_⟩
  · rw [moment_eq]
    have hm : 0 ≤ (theta ^ 2 - (32 / 37) ^ 2) * (3 - theta) :=
      mul_nonneg (by linarith) (by linarith [ht.2.1])
    nlinarith [hb.2]
  · rw [meanQ_eq]
    apply (lt_div_iff₀ (by linarith : 0 < 2 * (3 - theta))).2
    nlinarith [sq_nonneg (theta - 1)]
  · dsimp [p₂, c, dm]
    nlinarith

lemma affine_shape_integral (a b : ℝ) :
    (∫ q in (0 : ℝ)..1, (a + b * q) * shape q) = moment * (a + b * meanQ) := by
  have hc : IntervalIntegrable shape volume 0 1 := continuous_shape.intervalIntegrable 0 1
  have hq : IntervalIntegrable (fun q : ℝ => q * shape q) volume 0 1 :=
    (continuous_id.mul continuous_shape).intervalIntegrable 0 1
  have heq : (fun q : ℝ => (a + b * q) * shape q) =
      fun q => a * shape q + b * (q * shape q) := by funext q; ring
  rw [heq, intervalIntegral.integral_add (hc.const_mul a) (hq.const_mul b),
    intervalIntegral.integral_const_mul, intervalIntegral.integral_const_mul]
  change a * moment + b * firstMoment = moment * (a + b * meanQ)
  unfold meanQ
  field_simp [ne_of_gt moment_pos]

lemma cubic_shape_lower {a b : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) :
    moment * (a + b * meanQ) ^ 3 ≤
      ∫ q in (0 : ℝ)..1, (a + b * q) ^ 3 * shape q := by
  let m := a + b * meanQ
  have hm : 0 ≤ m := add_nonneg ha (mul_nonneg hb (le_of_lt meanQ_mem.1))
  have hc : IntervalIntegrable (fun q : ℝ => (a + b * q) ^ 3 * shape q) volume 0 1 :=
    (((continuous_const.add (continuous_const.mul continuous_id)).pow 3).mul continuous_shape).intervalIntegrable 0 1
  have h1 : IntervalIntegrable (fun q : ℝ => m ^ 3 * shape q) volume 0 1 :=
    (continuous_const.mul continuous_shape).intervalIntegrable 0 1
  have h2 : IntervalIntegrable (fun q : ℝ => (a + b * q - m) * shape q) volume 0 1 :=
    (( (continuous_const.add (continuous_const.mul continuous_id)).sub continuous_const).mul continuous_shape).intervalIntegrable 0 1
  have hbound := intervalIntegral.integral_mono_on (show (0 : ℝ) ≤ 1 by norm_num)
    (h1.add (h2.const_mul (3 * m ^ 2))) hc (fun q hq => by
      have hs := shape_nonneg hq
      have hf : 0 ≤ a + b * q := add_nonneg ha (mul_nonneg hb hq.1)
      have hh := mul_nonneg (mul_nonneg (sq_nonneg (a + b * q - m))
        (show 0 ≤ a + b * q + 2 * m by linarith)) hs
      nlinarith)
  rw [intervalIntegral.integral_add h1 (h2.const_mul (3 * m ^ 2)),
    intervalIntegral.integral_const_mul, intervalIntegral.integral_const_mul] at hbound
  have hz : (∫ q in (0 : ℝ)..1, (a + b * q - m) * shape q) = 0 := by
    have heq : (fun q : ℝ => (a + b * q - m) * shape q) =
        fun q => (a - m + b * q) * shape q := by funext q; ring
    rw [heq, affine_shape_integral]
    dsimp [m]
    ring
  rw [hz, mul_zero, add_zero] at hbound
  change moment * m ^ 3 ≤ _
  change m ^ 3 * moment ≤ _ at hbound
  linarith only [hbound]

lemma cubic_shape_lower_dm {u₀ δ : ℝ} (hδ : δ ∈ Icc 0 dm) (hu : dm ≤ u₀) :
    moment * (u₀ - (1 - meanQ) * dm) ^ 3 ≤
      ∫ q in (0 : ℝ)..1, (u₀ - δ + δ * q) ^ 3 * shape q := by
  have hm := meanQ_mem
  have h1 := cubic_shape_lower (a := u₀ - δ) (b := δ) (by linarith [hδ.2]) hδ.1
  apply le_trans _ h1
  apply mul_le_mul_of_nonneg_left _ (le_of_lt moment_pos)
  have hb : u₀ - (1 - meanQ) * dm ≤ u₀ - δ + δ * meanQ := by
    have hh := mul_le_mul_of_nonneg_left hδ.2 (show 0 ≤ 1 - meanQ by linarith [hm.2])
    nlinarith
  apply pow_le_pow_left₀ _ hb 3
  have hh : 0 ≤ dm * meanQ := mul_nonneg (by norm_num [dm]) (le_of_lt hm.1)
  nlinarith

lemma p₂_pos : 0 < p₂ := by
  unfold p₂ c dm
  positivity

lemma coefficient_lower : (574 / 1000 : ℝ) <
    ((91 / 100 : ℝ) * c * moment) / Real.sqrt p₂ ^ 3 := by
  have hM := moment_bounds.1
  have hp := moment_bounds.2.2
  have hs : 0 < Real.sqrt p₂ := Real.sqrt_pos.2 p₂_pos
  have hs2 := Real.sq_sqrt (le_of_lt p₂_pos)
  have hd : (Real.sqrt p₂ ^ 3) ^ 2 = p₂ ^ 3 := by
    rw [show (Real.sqrt p₂ ^ 3) ^ 2 = (Real.sqrt p₂ ^ 2) ^ 3 by ring, hs2]
  have hp3 := pow_lt_pow_left₀ hp (le_of_lt p₂_pos) (by norm_num : (3 : ℕ) ≠ 0)
  have hc : (574 / 1000 : ℝ) * Real.sqrt p₂ ^ 3 <
      (91 / 100 : ℝ) * c * (2659 / 10000 : ℝ) := by
    apply (sq_lt_sq₀ (by positivity)
      (by norm_num [c] : (0 : ℝ) ≤ (91 / 100 : ℝ) * c * (2659 / 10000 : ℝ))).1
    rw [mul_pow, hd]
    norm_num [c]
    nlinarith only [hp3]
  apply (lt_div_iff₀ (pow_pos hs 3)).2
  have hmc := mul_lt_mul_of_pos_left hM (by norm_num [c] : (0 : ℝ) < (91 / 100 : ℝ) * c)
  exact lt_trans hc hmc

end CubicTorus.Shape
end
end
end
end

end OAI