lean/OAI/Geometry/CylinderCovering/Singular/EdgeOne.lean

import OAI.Geometry.CylinderCovering.Singular.EdgeOneDefinitions

namespace OAI

noncomputable section
open Set Filter MeasureTheory
open scoped Topology

namespace SingularEdgeOne

lemma edgeU_eq (p w l : ℝ) : edgeU p w l = fieldP p (2 * w) l / 4 := by
  unfold edgeU fieldP
  ring

lemma edgeV_eq (p w : ℝ) {l : ℝ} (hl : 0 < l) :
    edgeV p w l = fieldQ p (2 * w) l / 2 := by
  have hr : (2 * l) ^ (p - 1) = (2 * l) ^ (p - 2) * (2 * l) := by
    rw [show p - 1 = (p - 2) + 1 by ring, Real.rpow_add_one (by positivity)]
  unfold edgeV fieldQ
  rw [hr]
  field_simp

lemma ceiling_rescaling (p w c : ℝ) :
    c ^ 2 * ceiling p (2 * w) = (4 * c) ^ 2 * edgeCeiling p w := by
  unfold ceiling edgeCeiling
  ring

lemma physical_speed_rescaling (p w c : ℝ) {l : ℝ} (hl : 0 < l) :
    (4 * c) ^ 2 * (edgeU p w l ^ 2 + (1 / 2 : ℝ) * edgeV p w l ^ 2) =
      c ^ 2 * (fieldP p (2 * w) l ^ 2 + 2 * fieldQ p (2 * w) l ^ 2) := by
  rw [edgeU_eq, edgeV_eq p w hl]
  ring

lemma physical_height_square : (1 / Real.sqrt 2 : ℝ) ^ 2 = 1 / 2 := by
  rw [div_pow, Real.sq_sqrt (by norm_num : (0 : ℝ) ≤ 2)]
  norm_num

lemma physical_speed_rescaling_sqrt (p w c : ℝ) {l : ℝ} (hl : 0 < l) :
    (4 * c) ^ 2 *
      (edgeU p w l ^ 2 + (1 / Real.sqrt 2 : ℝ) ^ 2 * edgeV p w l ^ 2) =
      c ^ 2 * (fieldP p (2 * w) l ^ 2 + 2 * fieldQ p (2 * w) l ^ 2) := by
  rw [physical_height_square]
  exact physical_speed_rescaling p w c hl

lemma edgeCeiling_level (p w : ℝ) : edgeCeiling p w = w ^ 2 * edgeU p w (1 / 2) := by
  have hpow : (2 * (1 / 2 : ℝ)) ^ (p - 1) = 1 := by norm_num
  rw [edgeCeiling, edgeU, hpow]
  ring

lemma coefficient_rescaling (p : ℝ) :
    coefficient p / 32 = (2 * p ^ 2 + 10 * p - 13) / (15360 * p) := by
  unfold coefficient
  ring

lemma edge_coefficient {p : ℝ} (hp : p ≠ 0) :
    edgeA p - edgeG p = (2 * p ^ 2 + 10 * p - 13) / (15360 * p) := by
  unfold edgeA edgeG
  field_simp
  ring

lemma edge_coefficient_eq_scaled {p : ℝ} (hp : p ≠ 0) :
    edgeA p - edgeG p = coefficient p / 32 := by
  rw [edge_coefficient hp, coefficient_rescaling]

lemma coefficient_at_one : coefficient 1 = -(1 / 480 : ℝ) := by
  norm_num [coefficient]

lemma edgeA_at_one : edgeA 1 = 16 / 15360 := by norm_num [edgeA]
lemma edgeG_at_one : edgeG 1 = 17 / 15360 := by norm_num [edgeG]

lemma edgeA_continuous : Continuous edgeA := by unfold edgeA; fun_prop
lemma edgeG_continuousAt {p : ℝ} (hp : p ≠ 0) : ContinuousAt edgeG p := by
  unfold edgeG
  fun_prop (disch := positivity)

lemma edgeA_limit : Tendsto edgeA (𝓝 1) (𝓝 (16 / 15360)) := by
  simpa only [edgeA_at_one] using edgeA_continuous.continuousAt.tendsto (x := (1 : ℝ))

lemma edgeG_limit : Tendsto edgeG (𝓝 1) (𝓝 (17 / 15360)) := by
  simpa only [edgeG_at_one] using (edgeG_continuousAt (by norm_num : (1 : ℝ) ≠ 0)).tendsto

lemma right_rpow_tendsto_zero {q : ℝ} (hq : 0 < q) :
    Tendsto (fun c : ℝ => c ^ q) (𝓝[>] 0) (𝓝 0) := by
  have h : Tendsto (fun c : ℝ => c ^ q) (𝓝[>] 0) (𝓝 ((0 : ℝ) ^ q)) :=
    ((Real.continuous_rpow_const hq.le).tendsto (0 : ℝ)).mono_left nhdsWithin_le_nhds
  simpa only [Real.zero_rpow hq.ne'] using h

lemma power_isLittleO_power {a b : ℝ} (hab : b < a) :
    Asymptotics.IsLittleO (𝓝[>] (0 : ℝ))
      (fun c : ℝ => c ^ a) (fun c : ℝ => c ^ b) := by
  rw [Asymptotics.isLittleO_iff_tendsto']
  · apply (right_rpow_tendsto_zero (sub_pos.mpr hab)).congr'
    filter_upwards [self_mem_nhdsWithin] with c hc
    exact Real.rpow_sub hc a b
  · filter_upwards [self_mem_nhdsWithin] with c hc
    exact fun h => False.elim ((Real.rpow_pos_of_pos hc b).ne' h)

lemma scaled_cutoff_small {p gamma A : ℝ} (hA : 0 < A)
    (hpg : gamma * (2 - p) < 1) :
    Tendsto (fun c : ℝ => c * (A * c ^ gamma) ^ (p - 2)) (𝓝[>] 0) (𝓝 0) := by
  have he : 0 < 1 + gamma * (p - 2) := by nlinarith
  have ht := (right_rpow_tendsto_zero he).const_mul (A ^ (p - 2))
  simp only [mul_zero] at ht
  apply ht.congr'
  filter_upwards [self_mem_nhdsWithin] with c hc
  rw [Real.mul_rpow hA.le (Real.rpow_nonneg hc.le _),
    ← Real.rpow_mul hc.le, Real.rpow_add hc, Real.rpow_one]
  ring

lemma power_flexibleCutoff {p gamma alpha A B : ℝ}
    (hA : 0 < A) (hB : 0 < B) (hg : 1 < gamma)
    (hpg : gamma * (2 - p) < 1) (ha : 2 < alpha) (ha3 : alpha < 3) :
    FlexibleCutoff p (fun c : ℝ => A * c ^ gamma) (fun c : ℝ => B * c ^ alpha) := by
  refine ⟨?_, ?_, scaled_cutoff_small hA hpg, ?_, ?_⟩
  · filter_upwards [self_mem_nhdsWithin] with c hc
    exact ⟨mul_pos hA (Real.rpow_pos_of_pos hc _),
      mul_pos hB (Real.rpow_pos_of_pos hc _)⟩
  · simpa only [Real.rpow_one] using (power_isLittleO_power hg).const_mul_left A
  · simpa only [Real.rpow_two] using (power_isLittleO_power ha).const_mul_left B
  · have hcube := Asymptotics.IsLittleO.const_mul_right hB.ne' (power_isLittleO_power ha3)
    have he : (fun c : ℝ => c ^ (3 : ℝ)) = fun c : ℝ => c ^ (3 : ℕ) :=
      funext (fun c => Real.rpow_natCast c 3)
    rw [he] at hcube
    exact hcube

lemma flexibleCutoff_congr {p : ℝ} {rho padding rho' padding' : ℝ → ℝ}
    (h : FlexibleCutoff p rho padding)
    (hr : rho =ᶠ[𝓝[>] (0 : ℝ)] rho') (hq : padding =ᶠ[𝓝[>] (0 : ℝ)] padding') :
    FlexibleCutoff p rho' padding' := by
  rcases h with ⟨hpos, hrsmall, hderiv, hqsmall, hcube⟩
  refine ⟨?_, hrsmall.congr' hr EventuallyEq.rfl, ?_,
    hqsmall.congr' hq EventuallyEq.rfl, hcube.congr' EventuallyEq.rfl hq⟩
  · filter_upwards [hpos, hr, hq] with c hc hrc hqc
    simpa only [← hrc, ← hqc] using hc
  · apply hderiv.congr'
    filter_upwards [hr] with c hc
    rw [hc]

lemma edgeOne_flexibleCutoff {p beta : ℝ} (hb : 1 < beta)
    (hbp : beta * (2 - p) < 1) :
    FlexibleCutoff p (fun c : ℝ => (4 * c) ^ beta)
      (fun c : ℝ => (4 * c) ^ (5 / 2 : ℝ)) := by
  have h := power_flexibleCutoff (p := p) (gamma := beta) (alpha := (5 / 2 : ℝ))
    (A := (4 : ℝ) ^ beta) (B := (4 : ℝ) ^ (5 / 2 : ℝ))
    (by positivity) (by positivity) hb hbp (by norm_num) (by norm_num)
  apply flexibleCutoff_congr h
  · filter_upwards [self_mem_nhdsWithin] with c hc
    exact (Real.mul_rpow (by norm_num : (0 : ℝ) ≤ 4) hc.le).symm
  · filter_upwards [self_mem_nhdsWithin] with c hc
    exact (Real.mul_rpow (by norm_num : (0 : ℝ) ≤ 4) hc.le).symm

lemma flexibleCutoff_tip_small {p : ℝ} {rho padding : ℝ → ℝ}
    (h : FlexibleCutoff p rho padding) :
    Asymptotics.IsLittleO (𝓝[>] (0 : ℝ))
      (fun c : ℝ => rho c ^ 2) (fun c : ℝ => c ^ 2) :=
  h.2.1.pow (by norm_num)

lemma parameters_imply_cutoff_bound {p gamma : ℝ} (hp : p < 2)
    (hg : gamma < 1 / (2 - p)) : gamma * (2 - p) < 1 :=
  (lt_div_iff₀ (sub_pos.mpr hp)).mp hg

lemma lower_sweep_dictionary (p c x y t b : ℝ) {r : ℝ} (hr : 0 < r) :
    (y = b + c * x * fieldP p b r ∧ t = r + c * x * fieldQ p b r) ↔
      (y / 2 = b / 2 + (4 * c) * (x / 2) * edgeU p (b / 2) r ∧
        t = r + (4 * c) * (x / 2) * edgeV p (b / 2) r) := by
  rw [edgeU_eq, edgeV_eq p (b / 2) hr]
  norm_num only [mul_div_cancel₀ _ (by norm_num : (2 : ℝ) ≠ 0)]
  constructor <;> rintro ⟨hy, ht⟩ <;> constructor <;> nlinarith [hy, ht]

lemma upper_sweep_dictionary (p c x y t b : ℝ) {r : ℝ} (hr : 0 < r) :
    (x = b - c * y * fieldP p b r ∧ 1 - t = r - c * y * fieldQ p b r) ↔
      (x / 2 = b / 2 - (4 * c) * (y / 2) * edgeU p (b / 2) r ∧
        1 - t = r - (4 * c) * (y / 2) * edgeV p (b / 2) r) := by
  rw [edgeU_eq, edgeV_eq p (b / 2) hr]
  norm_num only [mul_div_cancel₀ _ (by norm_num : (2 : ℝ) ≠ 0)]
  constructor <;> rintro ⟨hx, ht⟩ <;> constructor <;> nlinarith [hx, ht]

lemma cone_dictionary (b r : ℝ) : |b / 2| ≤ r / 2 ↔ |b| ≤ r := by
  rw [abs_div, abs_of_pos (by norm_num : (0 : ℝ) < 2)]
  constructor <;> intro h <;> linarith

lemma ceiling_dictionary (p b c r padding : ℝ) :
    (r ≤ 1 / 2 + c ^ 2 * ceiling p b + padding) ↔
      r ≤ 1 / 2 + (4 * c) ^ 2 * edgeCeiling p (b / 2) + padding := by
  have h := ceiling_rescaling p (b / 2) c
  simp only [show 2 * (b / 2) = b by ring] at h
  rw [h]

lemma edgeA_integral (p : ℝ) :
    (∫ w in (-1 / 4 : ℝ)..(1 / 4 : ℝ), edgeCeiling p w) = edgeA p := by
  have he : edgeCeiling p = fun w : ℝ => (2 - p) * w ^ 4 + (p / 16) * w ^ 2 := by
    funext w
    unfold edgeCeiling
    ring
  rw [he, intervalIntegral.integral_add
    ((by fun_prop : Continuous (fun w : ℝ => (2 - p) * w ^ 4)).intervalIntegrable _ _)
    ((by fun_prop : Continuous (fun w : ℝ => (p / 16) * w ^ 2)).intervalIntegrable _ _)]
  rw [intervalIntegral.integral_const_mul, intervalIntegral.integral_const_mul,
    integral_pow, integral_pow]
  norm_num [edgeA]
  ring

lemma angularEnergy_integral (p : ℝ) :
    (∫ R in (-1 / 2 : ℝ)..(1 / 2 : ℝ), angularEnergy p R) =
      (2 - p) ^ 2 / 2560 + p * (2 - p) / 768 + p ^ 2 / 512 + 1 / 192 := by
  have he : angularEnergy p = fun R : ℝ =>
      (2 - p) ^ 2 / 32 * R ^ 4 + (p * (2 - p) / 64 + 1 / 16) * R ^ 2 + p ^ 2 / 512 := by
    funext R
    unfold angularEnergy
    ring
  rw [he, intervalIntegral.integral_add
    ((by fun_prop : Continuous (fun R : ℝ =>
      (2 - p) ^ 2 / 32 * R ^ 4 + (p * (2 - p) / 64 + 1 / 16) * R ^ 2)).intervalIntegrable _ _)
    intervalIntegrable_const,
    intervalIntegral.integral_add
      ((by fun_prop : Continuous (fun R : ℝ => (2 - p) ^ 2 / 32 * R ^ 4)).intervalIntegrable _ _)
      ((by fun_prop : Continuous (fun R : ℝ =>
        (p * (2 - p) / 64 + 1 / 16) * R ^ 2)).intervalIntegrable _ _),
    intervalIntegral.integral_const_mul, intervalIntegral.integral_const_mul,
    integral_pow, integral_pow, intervalIntegral.integral_const]
  norm_num
  ring

lemma edgeEnergy_polar (p R : ℝ) {l : ℝ} (hl : 0 < l) :
    edgeEnergy p (l * R) l = (2 * l) ^ (2 * p - 2) * angularEnergy p R := by
  have hr : ((2 * l) ^ (p - 1)) ^ 2 = (2 * l) ^ (2 * p - 2) := by
    rw [← Real.rpow_natCast, ← Real.rpow_mul (by positivity : (0 : ℝ) ≤ 2 * l)]
    congr 1
    ring
  unfold edgeEnergy edgeU edgeV angularEnergy
  rw [mul_div_cancel_left₀ R hl.ne']
  nlinarith [hr]

lemma edgeEnergy_slice_integral (p : ℝ) {l : ℝ} (hl : 0 ≤ l) :
    (∫ w in (-l / 2)..(l / 2), edgeEnergy p w l) =
      l * (2 * l) ^ (2 * p - 2) *
        (∫ R in (-1 / 2 : ℝ)..(1 / 2 : ℝ), angularEnergy p R) := by
  by_cases hl0 : l = 0
  · subst l
    simp
  have hlp : 0 < l := lt_of_le_of_ne hl (Ne.symm hl0)
  have hs := intervalIntegral.smul_integral_comp_mul_left
    (a := (-1 / 2 : ℝ)) (b := (1 / 2 : ℝ)) (fun w : ℝ => edgeEnergy p w l) l
  simp only [smul_eq_mul] at hs
  have hleft : l * (-1 / 2 : ℝ) = -l / 2 := by ring
  have hright : l * (1 / 2 : ℝ) = l / 2 := by ring
  rw [hleft, hright] at hs
  rw [← hs]
  simp_rw [edgeEnergy_polar p _ hlp]
  rw [intervalIntegral.integral_const_mul]
  ring

lemma edge_radial_integral {p : ℝ} (hp : 0 < p) :
    (∫ l in (0 : ℝ)..(1 / 2 : ℝ), l * (2 * l) ^ (2 * p - 2)) = 1 / (8 * p) := by
  have he : (∫ l in (0 : ℝ)..(1 / 2 : ℝ), l * (2 * l) ^ (2 * p - 2)) =
      (∫ l in (0 : ℝ)..(1 / 2 : ℝ), (2 * l) ^ (2 * p - 1) / 2) := by
    apply intervalIntegral.integral_congr_Ioo_of_le (by norm_num)
    intro l hl
    have hlp : 0 < 2 * l := by linarith [hl.1]
    dsimp only
    rw [show 2 * p - 1 = (2 * p - 2) + 1 by ring, Real.rpow_add_one hlp.ne']
    ring
  rw [he, intervalIntegral.integral_div]
  have hs := intervalIntegral.integral_comp_mul_left
    (a := (0 : ℝ)) (b := (1 / 2 : ℝ)) (fun l : ℝ => l ^ (2 * p - 1))
    (c := (2 : ℝ)) (by norm_num)
  norm_num only [mul_zero, show (2 : ℝ) * (1 / 2) = 1 by norm_num, smul_eq_mul] at hs
  rw [hs, integral_rpow (Or.inl (by linarith : -1 < 2 * p - 1))]
  rw [show 2 * p - 1 + 1 = 2 * p by ring, Real.one_rpow,
    Real.zero_rpow (by positivity : 2 * p ≠ 0)]
  field_simp
  ring

lemma edgeG_iterated_integral {p : ℝ} (hp : 0 < p) :
    (∫ l in (0 : ℝ)..(1 / 2 : ℝ),
      ∫ w in (-l / 2)..(l / 2), edgeEnergy p w l) = edgeG p := by
  have he : (∫ l in (0 : ℝ)..(1 / 2 : ℝ),
      ∫ w in (-l / 2)..(l / 2), edgeEnergy p w l) =
      (∫ l in (0 : ℝ)..(1 / 2 : ℝ),
        (l * (2 * l) ^ (2 * p - 2)) *
          (∫ R in (-1 / 2 : ℝ)..(1 / 2 : ℝ), angularEnergy p R)) := by
    apply intervalIntegral.integral_congr_Ioo_of_le (by norm_num)
    intro l hl
    exact edgeEnergy_slice_integral p hl.1.le
  rw [he, intervalIntegral.integral_mul_const, edge_radial_integral hp,
    angularEnergy_integral]
  unfold edgeG
  field_simp
  ring

lemma coefficient_neg {p : ℝ} (hp : 1 < p)
    (hpmax : p < (Real.sqrt 51 - 5) / 2) : coefficient p < 0 := by
  have hsq : (2 * p + 5) ^ 2 < 51 := calc
    (2 * p + 5) ^ 2 < (Real.sqrt 51) ^ 2 :=
      (sq_lt_sq₀ (by linarith) (Real.sqrt_nonneg 51)).2 (by linarith)
    _ = 51 := Real.sq_sqrt (by norm_num)
  have hnum : 2 * p ^ 2 + 10 * p - 13 < 0 := by nlinarith
  exact div_neg_of_neg_of_pos (mul_neg_of_pos_of_neg (by norm_num) hnum)
    (by linarith : 0 < 30 * p)

lemma edge_coefficient_neg {p : ℝ} (hp : 1 < p)
    (hpmax : p < (Real.sqrt 51 - 5) / 2) : edgeA p - edgeG p < 0 := by
  rw [edge_coefficient_eq_scaled (by linarith : p ≠ 0)]
  exact div_neg_of_neg_of_pos (coefficient_neg hp hpmax) (by norm_num)

lemma four_rpow_five_halves : (4 : ℝ) ^ (5 / 2 : ℝ) = 32 := by
  rw [show (5 / 2 : ℝ) = 2 + (1 / 2) by norm_num,
    Real.rpow_add (by norm_num : (0 : ℝ) < 4), Real.rpow_two,
    ← Real.sqrt_eq_rpow]
  norm_num

lemma exact_padding_dictionary {k : ℝ} (hk : 0 ≤ k) :
    (k / 4) ^ (5 / 2 : ℝ) = k ^ (5 / 2 : ℝ) / 32 := by
  rw [Real.div_rpow hk (by norm_num), four_rpow_five_halves]

lemma exact_cutoff_dictionary {k : ℝ} (hk : 0 ≤ k) (gamma : ℝ) :
    (k / 4) ^ gamma = (4 : ℝ) ^ (-gamma) * k ^ gamma := by
  rw [Real.div_rpow hk (by norm_num), Real.rpow_neg (by norm_num : (0 : ℝ) ≤ 4)]
  ring

end SingularEdgeOne

end

end OAI