lean/OAI/NumberTheory/Jacobsthal/Analysis/WeightIntegrals.lean

import Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus
import Mathlib.Tactic
import OAI.NumberTheory.Jacobsthal.Paths.FiniteHistorySupport

namespace OAI

namespace Erdos970

section

namespace NumberTheoryLean.TwoStepDensityBounds

open Set
open DerivativeWeights WeightFutureIntegrals FinitePathGeometry

noncomputable def baseRatio : Side → ℝ | .even => 198 / 100 | .odd => 95 / 100

theorem baseRatio_valid (i : Side) : Valid i (baseRatio i) := by cases i <;> exact le_rfl

theorem baseRatio_le {i : Side} {s : ℝ} (hs : Valid i s) : baseRatio i ≤ s := by
  cases i <;> exact hs

theorem valid_of_three_le (i : Side) {s : ℝ} (hs : 3 ≤ s) : Valid i s := by
  cases i <;> dsimp [Valid] <;> linarith

theorem weight_antitone {i : Side} {s t : ℝ} (hs : Valid i s) (ht : Valid i t) (hst : s ≤ t) :
    weight i t ≤ weight i s := by
  cases i with
  | even =>
    exact phiEven_strictAntiOn.antitoneOn
      (by change 1 < s; dsimp [Valid] at hs; linarith)
      (by change 1 < t; dsimp [Valid] at ht; linarith) hst
  | odd => exact phiOdd_antitone hst

theorem two_step_density_eq {i : Side} {s t u : ℝ} (hs : Valid i s)
    (ht : minRatio i s ≤ t) (hu : minRatio i.flip t ≤ u) :
    transitionDensity i s t * transitionDensity i.flip t u =
      (W t * W u) * (weight i u / weight i s) := by
  have htV := valid_next hs ht
  have hw := weight_pos hs
  have hwt := weight_pos htV
  have hflip : i.flip.flip = i := by cases i <;> rfl
  unfold transitionDensity TransitionKernels.tailDensity
  rw [indicator_of_mem (show t ∈ Ici (minRatio i s) from ht),
    indicator_of_mem (show u ∈ Ici (minRatio i.flip t) from hu), hflip]
  field_simp

theorem rectangle_admissible {i : Side} {s L t u : ℝ} (hL : 3 ≤ L) (hsL : s ≤ L)
    (ht : t ∈ Icc L (L + 1)) (hu : u ∈ Icc (L + 1) (L + 2)) :
    minRatio i s ≤ t ∧ minRatio i.flip t ≤ u := by
  cases i <;> dsimp [minRatio, Side.flip]
  · constructor
    · linarith [ht.1]
    · apply max_le <;> linarith [ht.2, hu.1]
  · constructor
    · apply max_le <;> linarith [ht.1]
    · linarith [ht.2, hu.1]

theorem W_lower {t M : ℝ} (ht : 0 < t) (htM : t ≤ M) : 1 / M ≤ W t := by
  have hM : 0 < M := lt_of_lt_of_le ht htM
  unfold W
  apply (div_le_div_iff₀ hM (sq_pos_of_pos ht)).mpr
  nlinarith

noncomputable def rectangleLower (i : Side) (L : ℝ) : ℝ :=
  (1 / (L + 2)) ^ 2 * (weight i (L + 2) / weight i (baseRatio i))

theorem rectangleLower_pos (i : Side) {L : ℝ} (hL : 3 ≤ L) : 0 < rectangleLower i L := by
  unfold rectangleLower
  exact mul_pos (sq_pos_of_pos (one_div_pos.mpr (by linarith)))
    (div_pos (weight_pos (valid_of_three_le i (by linarith))) (weight_pos (baseRatio_valid i)))

theorem rectangle_density_lower {i : Side} {s L t u : ℝ} (hL : 3 ≤ L)
    (hs : Valid i s) (hsL : s ≤ L)
    (ht : t ∈ Icc L (L + 1)) (hu : u ∈ Icc (L + 1) (L + 2)) :
    rectangleLower i L ≤ transitionDensity i s t * transitionDensity i.flip t u := by
  obtain ⟨hadt, hadu⟩ := rectangle_admissible (i := i) hL hsL ht hu
  rw [two_step_density_eq hs hadt hadu]
  have ht0 : 0 < t := by linarith [ht.1]
  have hu0 : 0 < u := by linarith [hu.1]
  have htM : t ≤ L + 2 := by linarith [ht.2]
  have hW : (1 / (L + 2)) ^ 2 ≤ W t * W u := by
    simpa only [pow_two] using mul_le_mul (W_lower ht0 htM) (W_lower hu0 hu.2)
      (one_div_nonneg.mpr (by linarith)) (W_pos ht0).le
  have hsW := weight_pos hs
  have hbaseW := weight_pos (baseRatio_valid i)
  have hMW := weight_pos (valid_of_three_le i (s := L + 2) (by linarith))
  have huV := valid_of_three_le i (s := u) (by linarith [hu.1])
  have hden := weight_antitone (baseRatio_valid i) hs (baseRatio_le hs)
  have hnum := weight_antitone huV (valid_of_three_le i (s := L + 2) (by linarith)) hu.2
  have hratio : weight i (L + 2) / weight i (baseRatio i) ≤ weight i u / weight i s := by
    calc
      _ ≤ weight i (L + 2) / weight i s := div_le_div_of_nonneg_left hMW.le hsW hden
      _ ≤ _ := div_le_div_of_nonneg_right hnum hsW.le
  exact mul_le_mul hW hratio (div_pos hMW hbaseW).le (mul_pos (W_pos ht0) (W_pos hu0)).le

noncomputable def minorizationSize (L : ℝ) : ℝ :=
  min 1 (min (rectangleLower .even L) (rectangleLower .odd L))

theorem minorizationSize_pos {L : ℝ} (hL : 3 ≤ L) : 0 < minorizationSize L :=
  lt_min zero_lt_one (lt_min (rectangleLower_pos .even hL) (rectangleLower_pos .odd hL))

theorem minorizationSize_le_one (L : ℝ) : minorizationSize L ≤ 1 := min_le_left _ _

theorem minorizationSize_le_rectangle (i : Side) (L : ℝ) : minorizationSize L ≤ rectangleLower i L := by
  cases i with
  | even => exact le_trans (min_le_right _ _) (min_le_left _ _)
  | odd => exact le_trans (min_le_right _ _) (min_le_right _ _)

end NumberTheoryLean.TwoStepDensityBounds

end

section

open Set MeasureTheory
namespace Erdos970Dependency.WeightIntegrals
open NumberTheoryLean.DerivativeWeights NumberTheoryLean.WeightFutureIntegrals

noncomputable def wPrimitive (t : ℝ) : ℝ := Real.log t - 1 / t
noncomputable def wMass (a b : ℝ) : ℝ := ∫ t in a..b, W t

theorem W_continuousAt {t : ℝ} (ht : t ≠ 0) : ContinuousAt W t := by
  unfold W
  fun_prop (disch := simp [ht])

theorem wPrimitive_deriv {t : ℝ} (ht : 0 < t) : HasDerivAt wPrimitive (W t) t := by
  have h := (Real.hasDerivAt_log (ne_of_gt ht)).sub
    ((hasDerivAt_const t (1 : ℝ)).div (hasDerivAt_id t) (ne_of_gt ht))
  convert! h using 1
  simp only [W, id_eq, zero_mul, zero_sub, mul_one]
  field_simp
  ring

theorem wMass_eq {a b : ℝ} (ha : 0 < a) (hb : 0 < b) :
    wMass a b = wPrimitive b - wPrimitive a := by
  have hp (t : ℝ) (ht : t ∈ uIcc a b) : 0 < t :=
    lt_of_lt_of_le (lt_min ha hb) ht.1
  apply intervalIntegral.integral_eq_sub_of_hasDerivAt
  · intro t ht
    exact wPrimitive_deriv (hp t ht)
  · apply ContinuousOn.intervalIntegrable
    intro t ht
    exact (W_continuousAt (ne_of_gt (hp t ht))).continuousWithinAt

theorem wMass_nonneg {a b : ℝ} (ha : 0 < a) (hab : a ≤ b) : 0 ≤ wMass a b := by
  apply intervalIntegral.integral_nonneg hab
  intro t ht
  exact (W_pos (ha.trans_le ht.1)).le

theorem wMass_mono_right {a b c : ℝ} (ha : 0 < a) (hab : a ≤ b) (hbc : b ≤ c) :
    wMass a b ≤ wMass a c := by
  have hsplit : wMass a c = wMass a b + wMass b c := by
    rw [wMass_eq ha (ha.trans_le (hab.trans hbc)), wMass_eq ha (ha.trans_le hab),
      wMass_eq (ha.trans_le hab) (ha.trans_le (hab.trans hbc))]
    ring
  rw [hsplit]
  linarith [wMass_nonneg (ha.trans_le hab) hbc]

theorem wMass_two_three_lower : (1 : ℝ) / 3 ≤ wMass 2 3 := by
  have hW : ∀ t ∈ Icc (2 : ℝ) 3, (1 : ℝ) / 3 ≤ W t := by
    intro t ht
    exact NumberTheoryLean.TwoStepDensityBounds.W_lower (by linarith [ht.1]) ht.2
  have hI : IntervalIntegrable W volume 2 3 := by
    apply ContinuousOn.intervalIntegrable
    intro t ht
    rw [uIcc_of_le (by norm_num : (2 : ℝ) ≤ 3)] at ht
    exact (W_continuousAt (by linarith [ht.1])).continuousWithinAt
  have h := intervalIntegral.integral_mono_on (by norm_num : (2 : ℝ) ≤ 3)
    (by simp : IntervalIntegrable (fun _ : ℝ ↦ (1 : ℝ) / 3) volume 2 3) hI hW
  norm_num only [intervalIntegral.integral_const, smul_eq_mul] at h
  exact h

theorem wMass_initial_upper {a : ℝ} (ha : 99 / 100 ≤ a) (ha2 : a ≤ 2) : wMass a 2 ≤ 5 := by
  have ha0 : 0 < a := by linarith
  have hW : ∀ t ∈ Icc a (2 : ℝ), W t ≤ 4 := by
    intro t ht
    have ht0 : 0 < t := ha0.trans_le ht.1
    unfold W
    apply (div_le_iff₀ (sq_pos_of_pos ht0)).mpr
    nlinarith [sq_nonneg (t - 99 / 100), ht.1, ht.2]
  have hI : IntervalIntegrable W volume a 2 := by
    apply ContinuousOn.intervalIntegrable
    intro t ht
    rw [uIcc_of_le ha2] at ht
    exact (W_continuousAt (ne_of_gt (ha0.trans_le ht.1))).continuousWithinAt
  have h := intervalIntegral.integral_mono_on ha2 hI
    (by simp : IntervalIntegrable (fun _ : ℝ ↦ (4 : ℝ)) volume a 2) hW
  simp only [intervalIntegral.integral_const, smul_eq_mul] at h
  exact h.trans (by linarith)

noncomputable def tailW (u : ℝ) : ℝ := wPrimitive (u + 1) - wPrimitive 2

noncomputable def regIntegral (t : ℝ) : ℝ := ∫ u in (1 : ℝ)..t + 1, W u * tailW u

theorem tailW_measurable : Measurable tailW := by
  unfold tailW wPrimitive
  fun_prop

theorem tailW_eq_mass {u : ℝ} (hu : 1 ≤ u) : tailW u = wMass 2 (u + 1) := by
  rw [wMass_eq (by norm_num) (by linarith : 0 < u + 1)]
  rfl

theorem tailW_nonneg {u : ℝ} (hu : 1 ≤ u) : 0 ≤ tailW u := by
  rw [tailW_eq_mass hu]
  exact wMass_nonneg (by norm_num) (by linarith)

theorem tailW_continuousAt {u : ℝ} (hu : 0 < u) : ContinuousAt tailW u := by
  have hc := (wPrimitive_deriv (by linarith : 0 < u + 1)).continuousAt
  exact (hc.comp (f := fun x : ℝ ↦ x + 1) (x := u)
    (continuousAt_id.add continuousAt_const)).sub continuousAt_const

theorem regKernel_continuousOn {a b : ℝ} (ha : 0 < a) :
    ContinuousOn (fun u ↦ W u * tailW u) (Icc a b) := by
  intro u hu
  have hu0 : 0 < u := ha.trans_le hu.1
  exact ((W_continuousAt (ne_of_gt hu0)).mul (tailW_continuousAt hu0)).continuousWithinAt

theorem wKernel_intervalIntegrable {a b : ℝ} (ha : 0 < a) (hab : a ≤ b) :
    IntervalIntegrable W volume a b := by
  apply ContinuousOn.intervalIntegrable
  intro u hu
  rw [uIcc_of_le hab] at hu
  exact (W_continuousAt (ne_of_gt (ha.trans_le hu.1))).continuousWithinAt

theorem regIntegral_lower {t : ℝ} (ht : 2 ≤ t) :
    (1 : ℝ) / 3 * wMass 2 (t + 1) ≤ regIntegral t := by
  have h12 : IntervalIntegrable (fun u ↦ W u * tailW u) volume 1 2 :=
    (regKernel_continuousOn (b := 2) (by norm_num : (0 : ℝ) < 1)).intervalIntegrable_of_Icc (by norm_num)
  have h2T : IntervalIntegrable (fun u ↦ W u * tailW u) volume 2 (t + 1) :=
    (regKernel_continuousOn (b := t + 1) (by norm_num : (0 : ℝ) < 2)).intervalIntegrable_of_Icc (by linarith)
  have hfirst : 0 ≤ ∫ u in (1 : ℝ)..2, W u * tailW u := by
    apply intervalIntegral.integral_nonneg (by norm_num)
    intro u hu
    exact mul_nonneg (W_pos (by linarith [hu.1])).le (tailW_nonneg hu.1)
  have hbound : (1 : ℝ) / 3 * wMass 2 (t + 1) ≤ ∫ u in (2 : ℝ)..t + 1, W u * tailW u := by
    unfold wMass
    rw [← intervalIntegral.integral_const_mul]
    apply intervalIntegral.integral_mono_on (by linarith)
      ((wKernel_intervalIntegrable (by norm_num) (by linarith : (2 : ℝ) ≤ t + 1)).const_mul _) h2T
    intro u hu
    have htail : (1 : ℝ) / 3 ≤ tailW u := by
      rw [tailW_eq_mass (by linarith [hu.1])]
      exact wMass_two_three_lower.trans (wMass_mono_right (by norm_num) (by norm_num) (by linarith [hu.1]))
    simpa only [mul_comm] using mul_le_mul_of_nonneg_left htail (W_pos (by linarith [hu.1])).le
  have hsplit := intervalIntegral.integral_add_adjacent_intervals h12 h2T
  unfold regIntegral
  linarith

theorem regIntegral_nonneg {t : ℝ} (ht : 2 ≤ t) : 0 ≤ regIntegral t :=
  le_trans (mul_nonneg (by norm_num) (wMass_nonneg (by norm_num) (by linarith))) (regIntegral_lower ht)

theorem initial_integral_le {s t : ℝ} (hs : 199 / 100 ≤ s) (hsup : s ≤ 23 / 10) (ht : 2 ≤ t) :
    wMass (s - 1) (t + 1) ≤ 48 * regIntegral t := by
  have ha : 0 < s - 1 := by linarith
  have hsplit : wMass (s - 1) (t + 1) = wMass (s - 1) 2 + wMass 2 (t + 1) := by
    rw [wMass_eq ha (by linarith), wMass_eq ha (by norm_num), wMass_eq (by norm_num) (by linarith)]
    ring
  have hsmall := wMass_initial_upper (a := s - 1) (by linarith) (by linarith)
  have hbig : (1 : ℝ) / 3 ≤ wMass 2 (t + 1) :=
    wMass_two_three_lower.trans (wMass_mono_right (by norm_num) (by norm_num) (by linarith))
  have hreg := regIntegral_lower ht
  rw [hsplit]
  linarith

end Erdos970Dependency.WeightIntegrals

end

end Erdos970

end OAI