Blame for lean/OAI/Geometry/LatticeCovering/Rounding.lean

import OAI.Geometry.LatticeCovering.Concentration

namespace OAI

section
section
noncomputable section
open scoped BigOperators
open Real
noncomputable section
open scoped BigOperators
open MeasureTheory ProbabilityTheory Set
noncomputable section
open scoped BigOperators
open MeasureTheory Set
noncomputable section
open Module Submodule MeasureTheory
open scoped BigOperators

namespace SingleLatticeCovering.Folded
variable {ι : Type*} [Fintype ι]

lemma square_difference_le {x y δ : ℝ} (hx : |x| ≤ 1) (hy : |y| ≤ 1)
    (hd : |x-y| ≤ δ) : y^2-x^2 ≤ 2*δ := by
  have hsum : |y+x| ≤ 2 := (abs_add_le _ _).trans (by linarith)
  have hdiff : |y-x| ≤ δ := by simpa only [abs_sub_comm] using hd
  calc
    _ = (y-x)*(y+x) := by ring
    _ ≤ |(y-x)*(y+x)| := le_abs_self _
    _ = |y-x| * |y+x| := abs_mul _ _
    _ ≤ δ*2 := mul_le_mul hdiff hsum (abs_nonneg _) (le_trans (abs_nonneg _) hdiff)
    _ = _ := by ring

lemma gamma1_rounding_upper (h : ℝ) {x y δ : ℝ} (hx : |x| ≤ 1) (hy : |y| ≤ 1)
    (hd : |x-y| ≤ δ) : gamma1 (h*x) ≤ exp (h^2*δ)*gamma1 (h*y) := by
  have hs := mul_le_mul_of_nonneg_left (square_difference_le hx hy hd) (sq_nonneg h)
  have he : -(h*x)^2/2 ≤ h^2*δ + -(h*y)^2/2 := by nlinarith
  unfold gamma1
  rw [← mul_div_assoc, ← Real.exp_add]
  exact div_le_div_of_nonneg_right (Real.exp_le_exp.mpr he) (Real.sqrt_nonneg _)

lemma gamma1_rounding (h : ℝ) {x y δ : ℝ} (hx : |x| ≤ 1) (hy : |y| ≤ 1)
    (hd : |x-y| ≤ δ) :
    exp (-(h^2*δ))*gamma1 (h*y) ≤ gamma1 (h*x) ∧
      gamma1 (h*x) ≤ exp (h^2*δ)*gamma1 (h*y) := by
  refine ⟨?_, gamma1_rounding_upper h hx hy hd⟩
  have hb := gamma1_rounding_upper h hy hx (by simpa only [abs_sub_comm] using hd)
  calc
    _ ≤ exp (-(h^2*δ)) * (exp (h^2*δ)*gamma1 (h*x)) :=
      mul_le_mul_of_nonneg_left hb (Real.exp_pos _).le
    _ = _ := by rw [← mul_assoc, ← Real.exp_add]; simp

lemma abs_sub_bitValue {t : ℝ} (ht : t ∈ Set.Icc 0 1) (e : Bool) :
    |t-bitValue e| ≤ 1 := by
  apply abs_le.mpr
  cases e <;> simp only [bitValue, Bool.false_eq_true, ↓reduceIte, sub_zero] <;>
    constructor <;> linarith [ht.1, ht.2]

lemma density_rounding_upper {h s t δ : ℝ} (hh : 0 < h)
    (hs : s ∈ Set.Icc 0 1) (ht : t ∈ Set.Icc 0 1) (hd : |t-s| ≤ δ) :
    density h t ≤ exp (h^2*δ)*density h s := by
  have h0 := gamma1_rounding_upper h (abs_sub_bitValue ht false)
    (abs_sub_bitValue hs false) (show |(t-bitValue false)-(s-bitValue false)| ≤ δ by simpa using hd)
  have h1 := gamma1_rounding_upper h (abs_sub_bitValue ht true)
    (abs_sub_bitValue hs true) (show |(t-bitValue true)-(s-bitValue true)| ≤ δ by
      simpa only [sub_sub_sub_cancel_right] using hd)
  simp only [bitValue, Bool.false_eq_true, ↓reduceIte, sub_zero] at h0 h1
  have h0' := mul_le_mul_of_nonneg_left h0 hh.le
  have h1' := mul_le_mul_of_nonneg_left h1 hh.le
  unfold density
  nlinarith

lemma product_rounding {f g : ι → ℝ} (hf : ∀ j, 0 ≤ f j) (r : ℝ)
    (hfg : ∀ j, f j ≤ exp r*g j) :
    (∏ j, f j) ≤ exp ((Fintype.card ι : ℝ)*r)*(∏ j, g j) := by
  calc
    _ ≤ ∏ j, exp r*g j := Finset.prod_le_prod₀ (fun j _ => hf j) (fun j _ => hfg j)
    _ = _ := by
      rw [Finset.prod_mul_distrib, ← Real.exp_sum]
      simp

lemma folded_rounding_upper {h δ : ℝ} (hh : 0 < h) (s t : ι → ℝ)
    (hs : ∀ j, s j ∈ Set.Icc 0 1) (ht : ∀ j, t j ∈ Set.Icc 0 1)
    (hd : ∀ j, |t j-s j| ≤ δ) :
    folded h t ≤ exp ((Fintype.card ι : ℝ)*h^2*δ)*folded h s := by
  simpa only [folded, mul_assoc] using product_rounding
    (fun j => (density_pos hh (t j)).le) (h^2*δ)
    (fun j => density_rounding_upper hh (hs j) (ht j) (hd j))

lemma atom_eq_product (h : ℝ) (t : ι → ℝ) (e : ι → Bool) :
    atom h t e = ∏ j, h*gamma1 (h*(t j-bitValue (e j))) := by
  simp [atom, gamma, Finset.prod_mul_distrib]

lemma atom_rounding_upper {h δ : ℝ} (hh : 0 < h) (s t : ι → ℝ) (e : ι → Bool)
    (hs : ∀ j, s j ∈ Set.Icc 0 1) (ht : ∀ j, t j ∈ Set.Icc 0 1)
    (hd : ∀ j, |t j-s j| ≤ δ) :
    atom h t e ≤ exp ((Fintype.card ι : ℝ)*h^2*δ)*atom h s e := by
  rw [atom_eq_product, atom_eq_product]
  have hj (j : ι) : h*gamma1 (h*(t j-bitValue (e j))) ≤
      exp (h^2*δ)*(h*gamma1 (h*(s j-bitValue (e j)))) := by
    have hg := gamma1_rounding_upper h (abs_sub_bitValue (ht j) (e j))
      (abs_sub_bitValue (hs j) (e j))
      (show |(t j-bitValue (e j))-(s j-bitValue (e j))| ≤ δ by
        simpa only [sub_sub_sub_cancel_right] using hd j)
    nlinarith [mul_le_mul_of_nonneg_left hg hh.le]
  simpa only [mul_assoc] using product_rounding
    (fun j => mul_nonneg hh.le (gamma1_pos _).le) (h^2*δ) hj

lemma remove_exp_factor {a b η : ℝ} (h : b ≤ exp η*a) : exp (-η)*b ≤ a := by
  calc
    _ ≤ exp (-η)*(exp η*a) := mul_le_mul_of_nonneg_left h (Real.exp_pos _).le
    _ = _ := by rw [← mul_assoc, ← Real.exp_add]; simp



theorem rounding {h δ : ℝ} (hh : 0 < h) (s t : ι → ℝ) (e : ι → Bool)
    (hs : ∀ j, s j ∈ Set.Icc 0 1) (ht : ∀ j, t j ∈ Set.Icc 0 1)
    (hd : ∀ j, |t j-s j| ≤ δ) :
    exp (-((Fintype.card ι : ℝ)*h^2*δ))*folded h s ≤ folded h t ∧
    folded h t ≤ exp ((Fintype.card ι : ℝ)*h^2*δ)*folded h s ∧
    exp (-((Fintype.card ι : ℝ)*h^2*δ))*(folded h s*wordMass h s e) ≤ atom h t e ∧
    atom h t e ≤ exp ((Fintype.card ι : ℝ)*h^2*δ)*(folded h s*wordMass h s e) := by
  have hd' (j : ι) : |s j-t j| ≤ δ := by simpa only [abs_sub_comm] using hd j
  refine ⟨remove_exp_factor (folded_rounding_upper hh t s ht hs hd'),
    folded_rounding_upper hh s t hs ht hd, ?_, ?_⟩
  · rw [← folded_identity hh]
    exact remove_exp_factor (atom_rounding_upper hh t s e ht hs hd')
  · rw [← folded_identity hh]
    exact atom_rounding_upper hh s t e hs ht hd


end SingleLatticeCovering.Folded

namespace SingleLatticeCovering.Folded
open Set MeasureTheory Real ConstructionA
variable {ι : Type*} [Fintype ι] [DecidableEq ι]

lemma grid_anchor_mem_cube {ι : Type*} [Fintype ι] [DecidableEq ι] (p : ℕ) (hp : 0 < p) (z : ι → ZMod p) (j : ι) :
    anchor p z j ∈ Set.Icc 0 1 := by
  let : NeZero p := ⟨hp.ne'⟩
  have hp0 : (0 : ℝ) < p := by exact_mod_cast hp
  refine ⟨div_nonneg (Nat.cast_nonneg _) hp0.le, ?_⟩
  apply (div_le_one hp0).mpr
  exact_mod_cast (ZMod.val_lt (z j)).le

lemma grid_distance {ι : Type*} [Fintype ι] [DecidableEq ι] {p : ℕ} {z : ι → ZMod p} {t : ι → ℝ} (ht : t ∈ gridCell p z) (j : ι) :
    |t j-anchor p z j| ≤ (p : ℝ)⁻¹ := by
  rw [abs_of_nonneg (ht j).1]
  exact (ht j).2.le

lemma grid_folded_integrable (h : ℝ) (p : ℕ) (hp : 0 < p) (z : ι → ZMod p) :
    IntegrableOn (folded h) (gridCell p z) := by
  apply ((continuous_folded h).continuousOn.integrableOn_compact
    (isCompact_univ_pi (fun _ => isCompact_Icc) : IsCompact (cube : Set (ι → ℝ)))).mono_set
  intro t ht
  exact Set.mem_univ_pi.mpr (fun j => (gridCell_subset_cube p hp z t ht j).imp_right le_of_lt)

lemma grid_integral_upper {h : ℝ} (hh : 0 < h) (p : ℕ) (hp : 0 < p) (z : ι → ZMod p) :
    (∫ t in gridCell p z, folded h t) ≤
      Real.exp ((Fintype.card ι : ℝ)*h^2*(p : ℝ)⁻¹)*folded h (anchor p z)*((p : ℝ)⁻¹)^Fintype.card ι := by
  have hfin : volume (gridCell p z) ≠ ⊤ := by rw [gridCell_volume]; finiteness
  calc
    _ ≤ ∫ _ in gridCell p z, Real.exp ((Fintype.card ι : ℝ)*h^2*(p : ℝ)⁻¹)*folded h (anchor p z) := by
      apply setIntegral_mono_on (grid_folded_integrable h p hp z) (integrableOn_const hfin) (gridCell_measurable p z)
      intro t ht
      exact folded_rounding_upper hh _ _ (grid_anchor_mem_cube p hp z)
        (fun j => (gridCell_subset_cube p hp z t ht j).imp_right le_of_lt) (grid_distance ht)
    _ = _ := by simp [gridCell_volume_real, mul_comm]

lemma grid_integral_lower {h : ℝ} (hh : 0 < h) (p : ℕ) (hp : 0 < p) (z : ι → ZMod p) :
    Real.exp (-((Fintype.card ι : ℝ)*h^2*(p : ℝ)⁻¹))*folded h (anchor p z)*((p : ℝ)⁻¹)^Fintype.card ι ≤
      (∫ t in gridCell p z, folded h t) := by
  have hfin : volume (gridCell p z) ≠ ⊤ := by rw [gridCell_volume]; finiteness
  calc
    _ = ∫ _ in gridCell p z, Real.exp (-((Fintype.card ι : ℝ)*h^2*(p : ℝ)⁻¹))*folded h (anchor p z) := by
      simp [gridCell_volume_real, mul_comm]
    _ ≤ _ := by
      apply setIntegral_mono_on (integrableOn_const hfin) (grid_folded_integrable h p hp z) (gridCell_measurable p z)
      intro t ht
      apply remove_exp_factor
      exact folded_rounding_upper hh _ _
        (fun j => (gridCell_subset_cube p hp z t ht j).imp_right le_of_lt) (grid_anchor_mem_cube p hp z)
        (fun j => by rw [abs_sub_comm]; exact grid_distance ht j)


def gridMass (h : ℝ) (p : ℕ) [NeZero p] (E : Finset (ι → ZMod p)) : ℝ :=
  ((p : ℝ)⁻¹)^Fintype.card ι * ∑ z ∈ E, folded h (anchor p z)

lemma grid_integral_total {h : ℝ} (hh : 0 < h) (p : ℕ) [NeZero p] (hp : 0 < p) :
    Real.exp (-((Fintype.card ι : ℝ)*h^2*(p : ℝ)⁻¹))*gridMass (ι := ι) h p Finset.univ ≤ (totalMass h)^Fintype.card ι ∧
    (totalMass h)^Fintype.card ι ≤ Real.exp ((Fintype.card ι : ℝ)*h^2*(p : ℝ)⁻¹)*gridMass (ι := ι) h p Finset.univ := by
  have he : (totalMass h)^Fintype.card ι =
      ∑ z : ι → ZMod p, ∫ t in gridCell p z, folded h t :=
    (cube_integral (ι := ι) hh).symm.trans (integral_gridCells hp (continuous_folded h))
  simp only [he]
  constructor
  · calc
      _ = ∑ z : ι → ZMod p, Real.exp (-((Fintype.card ι : ℝ)*h^2*(p : ℝ)⁻¹))*folded h (anchor p z)*((p : ℝ)⁻¹)^Fintype.card ι := by
        simp only [gridMass, Finset.mul_sum]
        apply Finset.sum_congr rfl
        intro z _
        ring
      _ ≤ _ := Finset.sum_le_sum (fun z _ => grid_integral_lower hh p hp z)
  · calc
      _ ≤ ∑ z : ι → ZMod p, Real.exp ((Fintype.card ι : ℝ)*h^2*(p : ℝ)⁻¹)*folded h (anchor p z)*((p : ℝ)⁻¹)^Fintype.card ι :=
        Finset.sum_le_sum (fun z _ => grid_integral_upper hh p hp z)
      _ = _ := by
        simp only [gridMass, Finset.mul_sum]
        apply Finset.sum_congr rfl
        intro z _
        ring


end SingleLatticeCovering.Folded

namespace SingleLatticeCovering.Folded
open Set MeasureTheory Real ConstructionA
variable {ι : Type*} [Fintype ι] [DecidableEq ι]

lemma halfCube_ae_cube {ι : Type*} [Fintype ι] [DecidableEq ι] : Set.univ.pi (fun _ : ι => Ico (0 : ℝ) 1) =ᵐ[volume] (cube : Set (ι → ℝ)) := by
  rw [volume_pi]
  exact Measure.pi_Ico_ae_eq_pi_Icc

lemma grid_selected_integral {h : ℝ} (hh : 0 < h) (p : ℕ) [NeZero p] (hp : 0 < p)
    (E : Finset (ι → ZMod p)) :
    (∫ t in ⋃ z ∈ E, gridCell p z, folded h t) ≤
      Real.exp ((Fintype.card ι : ℝ)*h^2*(p : ℝ)⁻¹)*gridMass h p E := by
  rw [integral_biUnion_finset E (fun z _ => gridCell_measurable p z)
    (fun z _ w _ hzw => gridCell_disjoint hp hzw) (fun z _ => grid_folded_integrable h p hp z)]
  calc
    _ ≤ ∑ z ∈ E, Real.exp ((Fintype.card ι : ℝ)*h^2*(p : ℝ)⁻¹)*folded h (anchor p z)*((p : ℝ)⁻¹)^Fintype.card ι :=
      Finset.sum_le_sum (fun z _ => grid_integral_upper hh p hp z)
    _ = _ := by
      simp only [gridMass, Finset.mul_sum]
      apply Finset.sum_congr rfl
      intro z _
      ring

lemma grid_integral_event {h : ℝ} (hh : 0 < h) (p : ℕ) [NeZero p] (hp : 0 < p)
    (E : Finset (ι → ZMod p)) (G : Set (ι → ℝ))
    (hG : ∀ t ∈ G, (∀ j, t j ∈ Ico 0 1) → residue p (floorVector p t) ∈ E) :
    (∫ t in G ∩ cube, folded h t) ≤
      Real.exp ((Fintype.card ι : ℝ)*h^2*(p : ℝ)⁻¹)*gridMass h p E := by
  have hi : IntegrableOn (folded h) (⋃ z ∈ E, gridCell p z) := by
    apply ((continuous_folded h).continuousOn.integrableOn_compact
      (isCompact_univ_pi (fun _ => isCompact_Icc) : IsCompact (cube : Set (ι → ℝ)))).mono_set
    intro t ht
    rcases Set.mem_iUnion.mp ht with ⟨z,ht⟩
    rcases Set.mem_iUnion.mp ht with ⟨hz,ht⟩
    exact Set.mem_univ_pi.mpr (fun j => (gridCell_subset_cube p hp z t ht j).imp_right le_of_lt)
  apply (setIntegral_mono_set hi (Filter.Eventually.of_forall (fun t => (folded_pos hh t).le)) ?_).trans
    (grid_selected_integral hh p hp E)
  filter_upwards [halfCube_ae_cube (ι := ι)] with t ht
  intro htg
  have hc : ∀ j, t j ∈ Ico 0 1 := Set.mem_univ_pi.mp (ht.mpr htg.2)
  exact Set.mem_iUnion.mpr ⟨_, Set.mem_iUnion.mpr ⟨hG t htg.1 hc, cube_mem_gridCell hp hc⟩⟩

lemma log_folded_grid_distance {h : ℝ} (hh : 0 < h) (p : ℕ) (hp : 0 < p)
    {z : ι → ZMod p} {t : ι → ℝ} (ht : t ∈ gridCell p z) :
    |Real.log (folded h t)-Real.log (folded h (anchor p z))| ≤
      (Fintype.card ι : ℝ)*h^2*(p : ℝ)⁻¹ := by
  have hu := folded_rounding_upper hh (anchor p z) t (grid_anchor_mem_cube p hp z)
    (fun j => (gridCell_subset_cube p hp z t ht j).imp_right le_of_lt) (grid_distance ht)
  have hl := folded_rounding_upper hh t (anchor p z)
    (fun j => (gridCell_subset_cube p hp z t ht j).imp_right le_of_lt) (grid_anchor_mem_cube p hp z)
    (fun j => by rw [abs_sub_comm]; exact grid_distance ht j)
  have hu' := Real.log_le_log (folded_pos hh t) hu
  have hl' := Real.log_le_log (folded_pos hh (anchor p z)) hl
  rw [Real.log_mul (Real.exp_ne_zero _) (folded_pos hh _).ne', Real.log_exp] at hu' hl'
  exact abs_le.mpr ⟨by linarith,by linarith⟩


def gridEligible (h μ D r : ℝ) (p : ℕ) [NeZero p] : Finset (ι → ZMod p) := by
  classical
  exact Finset.univ.filter (fun z => |Real.log (folded h (anchor p z))-(Fintype.card ι : ℝ)*μ| ≤ D ∧
    r ≤ (Finset.univ.filter fun j => |anchor p z j-1/2| ≤ (h^2)⁻¹).card)

lemma round_into_eligible {h c r : ℝ} (hh : 0 < h) (p : ℕ) [NeZero p] (hp : 0 < p)
    (hη : (Fintype.card ι : ℝ)*h^2*(p : ℝ)⁻¹ ≤ c)
    (hw : (p : ℝ)⁻¹ ≤ 1/(2*h^2)) {t : ι → ℝ} (ht : ∀ j, t j ∈ Ico 0 1)
    (hg : |Real.log (folded h t)-(Fintype.card ι : ℝ)*logMean h| < c ∧
      r ≤ ∑ j, (centralInterval h).indicator (fun _ => (1 : ℝ)) (t j)) :
    residue p (floorVector p t) ∈ gridEligible h (logMean h) (2*c) r p := by
  classical
  let z := residue p (floorVector p t)
  have hc := cube_mem_gridCell hp ht
  change z ∈ _
  simp only [gridEligible, Finset.mem_filter, Finset.mem_univ, true_and]
  constructor
  · have hd := log_folded_grid_distance hh p hp hc
    have htr := abs_add_le (Real.log (folded h (anchor p z))-Real.log (folded h t))
      (Real.log (folded h t)-(Fintype.card ι : ℝ)*logMean h)
    rw [sub_add_sub_cancel, abs_sub_comm (Real.log (folded h (anchor p z))) (Real.log (folded h t))] at htr
    linarith
  · apply hg.2.trans
    have he : ((Finset.univ.filter fun j => |anchor p z j-1/2| ≤ (h^2)⁻¹).card : ℝ) =
        ∑ j, if |anchor p z j-1/2| ≤ (h^2)⁻¹ then (1 : ℝ) else 0 := by
      simp only [←Finset.sum_filter, Finset.sum_const, nsmul_eq_mul, mul_one]
    rw [he]
    apply Finset.sum_le_sum
    intro j _
    by_cases hj : t j ∈ centralInterval h
    · have hti : |t j-1/2| ≤ 1/(2*h^2) := abs_le.mpr ⟨by linarith [hj.1],by linarith [hj.2]⟩
      have hd := grid_distance hc j
      have hz : |anchor p z j-1/2| ≤ (h^2)⁻¹ := by
        have ha := abs_add_le (anchor p z j-t j) (t j-1/2)
        rw [sub_add_sub_cancel, abs_sub_comm (anchor p z j) (t j)] at ha
        have he : 1/(2*h^2)+1/(2*h^2) = (h^2)⁻¹ := by field_simp; ring
        linarith
      simp only [Set.indicator_of_mem hj, ite_eq_left hz, le_refl]
    · simp only [Set.indicator_of_notMem hj]
      split_ifs <;> norm_num


end SingleLatticeCovering.Folded

namespace SingleLatticeCovering.Folded
open Set MeasureTheory Real ConstructionA
variable {ι : Type*} [Fintype ι] [DecidableEq ι]

lemma gridMass_nonneg {ι : Type*} [Fintype ι] [DecidableEq ι] {h : ℝ} (hh : 0 < h) (p : ℕ) [NeZero p] (E : Finset (ι → ZMod p)) :
    0 ≤ gridMass h p E :=
  mul_nonneg (by positivity) (Finset.sum_nonneg (fun _ _ => (folded_pos hh _).le))

lemma gridMass_mono {ι : Type*} [Fintype ι] [DecidableEq ι] {h : ℝ} (hh : 0 < h) (p : ℕ) [NeZero p]
    {E F : Finset (ι → ZMod p)} (hEF : E ⊆ F) : gridMass h p E ≤ gridMass h p F := by
  apply mul_le_mul_of_nonneg_left (Finset.sum_le_sum_of_subset_of_nonneg hEF (fun _ _ _ => (folded_pos hh _).le))
  positivity

lemma exp_small_upper {η : ℝ} (hη : 0 ≤ η) (hη' : η ≤ 1/2) : Real.exp η ≤ 1+2*η := by
  apply (Real.exp_bound_div_one_sub_of_interval hη (by linarith)).trans
  apply (div_le_iff₀ (by linarith : 0 < 1-η)).mpr
  nlinarith

lemma grid_from_continuous {h A B : ℝ} (hh : 0 < h) (hA : 0 ≤ A) (hB : 0 ≤ B)
    (p : ℕ) [NeZero p] (hp : 0 < p)
    (E : Finset (ι → ZMod p)) (G : Set (ι → ℝ)) (hG : MeasurableSet G)
    (hRound : ∀ t ∈ G, (∀ j, t j ∈ Ico 0 1) → residue p (floorVector p t) ∈ E)
    (ha : 1-(totalMass h)^Fintype.card ι ≤ A)
    (hg : 1-B ≤ (cubeLaw h : Measure (ι → ℝ)).real G)
    (hη : (Fintype.card ι : ℝ)*h^2*(p : ℝ)⁻¹ ≤ 1/2) :
    |gridMass (ι := ι) h p Finset.univ-1| ≤ A+2*((Fintype.card ι : ℝ)*h^2*(p : ℝ)⁻¹) ∧
    |gridMass h p E-1| ≤ A+B+2*((Fintype.card ι : ℝ)*h^2*(p : ℝ)⁻¹) := by
  let η := (Fintype.card ι : ℝ)*h^2*(p : ℝ)⁻¹
  let a := (totalMass h)^Fintype.card ι
  let q := (cubeLaw h : Measure (ι → ℝ)).real G
  change _ ≤ A+2*η ∧ _ ≤ A+B+2*η
  have hη0 : 0 ≤ η := by dsimp [η]; positivity
  have hη1 : η ≤ 1/2 := hη
  have ha0 : 0 ≤ a := pow_nonneg (totalMass_pos hh).le _
  have ha1 : a ≤ 1 := by simpa using pow_le_pow_left₀ (totalMass_pos hh).le (totalMass_le_one hh) (Fintype.card ι)
  let := cubeLaw_isProbability (ι := ι) hh
  have hq0 : 0 ≤ q := measureReal_nonneg
  have hq1 : q ≤ 1 := measureReal_le_one
  have haq0 : 0 ≤ a*q := mul_nonneg ha0 hq0
  have haq1 : a*q ≤ 1 := (mul_le_mul_of_nonneg_right ha1 hq0).trans (by simpa using hq1)
  have haq : 1-A-B ≤ a*q := by
    have ht := mul_nonneg (sub_nonneg.mpr ha1) (sub_nonneg.mpr hq1)
    change 1-a ≤ A at ha
    change 1-B ≤ q at hg
    nlinarith
  have hexp : 1-η ≤ Real.exp (-η) := by linarith [Real.add_one_le_exp (-η)]
  have htot := grid_integral_total (ι := ι) hh p hp
  have htu : gridMass (ι := ι) h p Finset.univ ≤ 1+2*η := by
    calc
      _ = Real.exp η*(Real.exp (-η)*gridMass (ι := ι) h p Finset.univ) := by rw [←mul_assoc,←Real.exp_add]; simp
      _ ≤ Real.exp η*a := mul_le_mul_of_nonneg_left htot.1 (Real.exp_pos _).le
      _ ≤ Real.exp η := mul_le_of_le_one_right (Real.exp_pos _).le ha1
      _ ≤ _ := exp_small_upper hη0 hη1
  have htl : 1-A-η ≤ gridMass (ι := ι) h p Finset.univ := by
    have ht := remove_exp_factor htot.2
    have ht' := mul_le_mul_of_nonneg_right hexp ha0
    change 1-a ≤ A at ha
    have hn := mul_nonneg hη0 (sub_nonneg.mpr ha1)
    nlinarith
  have hge : a*q = ∫ t in G ∩ cube, folded h t := by
    dsimp [a,q]
    rw [cubeLaw_real hh hG]
    rw [mul_div_cancel₀ _ (pow_ne_zero _ (totalMass_pos hh).ne')]
  have hgl : 1-A-B-η ≤ gridMass h p E := by
    have ht := remove_exp_factor (grid_integral_event hh p hp E G hRound)
    rw [←hge] at ht
    have ht' := mul_le_mul_of_nonneg_right hexp haq0
    have hn := mul_nonneg hη0 (sub_nonneg.mpr haq1)
    nlinarith
  have hgu := (gridMass_mono hh p (Finset.subset_univ E)).trans htu
  constructor <;> apply abs_le.mpr <;> constructor <;> linarith


def continuousGood (h c r : ℝ) : Set (ι → ℝ) :=
  {t | |Real.log (folded h t)-(Fintype.card ι : ℝ)*logMean h| < c ∧
    r ≤ ∑ j, (centralInterval h).indicator (fun _ => (1 : ℝ)) (t j)}

lemma continuousGood_measurable {ι : Type*} [Fintype ι] [DecidableEq ι] {h c r : ℝ} (hh : 0 < h) :
    MeasurableSet (continuousGood (ι := ι) h c r) := by
  have hc : Measurable (fun t : ι → ℝ => ∑ j, (centralInterval h).indicator
      (fun _ => (1 : ℝ)) (t j)) := by
    exact Finset.measurable_sum _ (fun j _ =>
      (measurable_const.indicator (show MeasurableSet (centralInterval h) from measurableSet_Icc)).comp (measurable_pi_apply j))
  exact (measurableSet_lt (((continuous_folded h).log (fun t => (folded_pos hh t).ne')).sub continuous_const).abs.measurable
    measurable_const).inter (measurableSet_le measurable_const hc)


end SingleLatticeCovering.Folded





noncomputable section
open Real Filter Topology
namespace SingleLatticeCovering.Folded

lemma prime_in_log_interval {s r : ℝ} (hs : 0 ≤ s) (hr : Real.log 4 ≤ r) :
    ∃ p : ℕ, p.Prime ∧ s ≤ Real.log p ∧ Real.log p ≤ s+r := by
  have he : 1 ≤ Real.exp s := Real.one_le_exp_iff.mpr hs
  have hn : 0 < ⌈Real.exp s⌉₊ := Nat.ceil_pos.mpr (Real.exp_pos _)
  obtain ⟨p,hp,hpl,hpu⟩ := Nat.exists_prime_lt_and_le_two_mul ⌈Real.exp s⌉₊ hn.ne'
  have hpl' : Real.exp s ≤ (p : ℝ) :=
    (Nat.le_ceil _).trans (by exact_mod_cast hpl.le)
  have hpu' : (p : ℝ) ≤ 4*Real.exp s := by
    have h := Nat.ceil_lt_add_one (Real.exp_pos s).le
    have h' : (p : ℝ) ≤ 2*(⌈Real.exp s⌉₊ : ℝ) := by exact_mod_cast hpu
    linarith
  have h4 : (4 : ℝ) ≤ Real.exp r := (Real.log_le_iff_le_exp (by norm_num)).mp hr
  refine ⟨p,hp,(Real.le_log_iff_exp_le (by exact_mod_cast hp.pos)).mpr hpl',?_⟩
  apply (Real.log_le_iff_le_exp (by exact_mod_cast hp.pos)).mpr
  calc
    _ ≤ 4*Real.exp s := hpu'
    _ ≤ Real.exp r*Real.exp s := mul_le_mul_of_nonneg_right h4 (Real.exp_pos _).le
    _ = _ := by rw [←Real.exp_add, add_comm]


theorem block_prime {b μ : ℝ} (_ : 0 < b)
    (hμ : 4*b^(56/100 : ℝ) ≤ b*μ) (hr : Real.log 4 ≤ b^(56/100 : ℝ)) :
    ∃ p : ℕ, p.Prime ∧ b*μ-4*b^(56/100 : ℝ) ≤ Real.log p ∧
      Real.log p ≤ b*μ-3*b^(56/100 : ℝ) := by
  obtain ⟨p,hp,hl,hu⟩ := prime_in_log_interval (sub_nonneg.mpr hμ) hr
  refine ⟨p,hp,hl,?_⟩
  linarith [hu]



theorem eventually_block_prime {μ : ℝ → ℝ} (hμ : Tendsto μ atTop atTop) :
    ∀ᶠ b : ℝ in atTop, ∃ p : ℕ, p.Prime ∧
      b*μ b-4*b^(56/100 : ℝ) ≤ Real.log p ∧
      Real.log p ≤ b*μ b-3*b^(56/100 : ℝ) := by
  have hpow : ∀ᶠ b : ℝ in atTop, 4*b^(56/100 : ℝ) ≤ b := by
    have ht := (tendsto_rpow_neg_atTop (by norm_num : (0 : ℝ) < 44/100)).const_mul (4 : ℝ)
    filter_upwards [ht.eventually (gt_mem_nhds (by norm_num : (4 : ℝ)*0 < 1)),
      eventually_gt_atTop (0 : ℝ)] with b hb hb0
    have hh : b^(-(44/100 : ℝ)) = b^(56/100 : ℝ)/b := by
      calc
        _ = b^((56/100 : ℝ)-1) := by congr 1; norm_num
        _ = _ := by rw [Real.rpow_sub hb0, Real.rpow_one]
    rw [hh] at hb
    have hbb : 4*b^(56/100 : ℝ)/b < 1 := by simpa only [mul_div_assoc] using hb
    exact (by nlinarith [(div_lt_iff₀ hb0).mp hbb])
  filter_upwards [eventually_gt_atTop (0 : ℝ), hμ.eventually (eventually_ge_atTop (1 : ℝ)),
    hpow, (tendsto_rpow_atTop (by norm_num : (0 : ℝ) < 56/100)).eventually
      (eventually_ge_atTop (Real.log 4))] with b hb hμb hpb hr
  exact block_prime hb (hpb.trans (by nlinarith)) hr



end SingleLatticeCovering.Folded


namespace SingleLatticeCovering.Folded
open Real Filter Topology Asymptotics

lemma eventually_totalMass_half : ∀ᶠ h : ℝ in atTop, 1/2 ≤ totalMass h := by
  filter_upwards [eventually_ge_atTop (1 : ℝ), eventually_ge_atTop (2*Real.log 4)] with h hh hl
  have hp : 0 < h := by linarith
  have he : Real.exp (-(h^2)/2) ≤ (1/4 : ℝ) := by
    calc
      _ ≤ Real.exp (-Real.log 4) := Real.exp_le_exp.mpr (by nlinarith)
      _ = _ := by rw [Real.exp_neg, Real.exp_log (by norm_num)]; norm_num
  linarith [totalMass_tail hp]

lemma logMean_tendsto : Tendsto logMean atTop atTop := by
  have hl : Tendsto (fun h : ℝ => Real.log h + (-Real.log (Real.sqrt (2*Real.pi))-1)) atTop atTop :=
    tendsto_atTop_add_const_right _ _ Real.tendsto_log_atTop
  apply tendsto_atTop_mono' _ _ hl
  filter_upwards [eventually_totalMass_half, eventually_gt_atTop (0 : ℝ)] with h ha hh
  have hb := logMean_lower_of_half hh ha
  linarith



def heightR (b : ℝ) : ℝ := Real.sqrt ((9/4 : ℝ)*Real.log b)

lemma heightR_tendsto : Tendsto heightR atTop atTop :=
  Real.tendsto_sqrt_atTop.comp (Tendsto.const_mul_atTop (by norm_num : (0 : ℝ) < 9/4) Real.tendsto_log_atTop)

lemma height_tendsto : Tendsto height atTop atTop :=
  heightR_tendsto.comp tendsto_natCast_atTop_atTop

lemma heightR_sq {b : ℝ} (hb : 1 ≤ b) : heightR b^2 = (9/4 : ℝ)*Real.log b :=
  Real.sq_sqrt (mul_nonneg (by norm_num) (Real.log_nonneg hb))

lemma heightR_pos {b : ℝ} (hb : 1 < b) : 0 < heightR b :=
  Real.sqrt_pos.mpr (mul_pos (by norm_num) (Real.log_pos hb))

lemma heightR_exp {b : ℝ} (hb : 1 ≤ b) (c : ℝ) :
    Real.exp (-(heightR b^2)*c) = b^(-(9/4 : ℝ)*c) := by
  rw [heightR_sq hb, Real.rpow_def_of_pos (lt_of_lt_of_le (by norm_num : (0 : ℝ) < 1) hb)]
  congr 1
  ring

lemma totalMass_power_loss {h : ℝ} (hh : 0 < h) (b : ℕ) :
    0 ≤ 1-(totalMass h)^b ∧ 1-(totalMass h)^b ≤ 2*(b : ℝ)*Real.exp (-(h^2)/2) := by
  have ha := totalMass_pos hh
  have hu := totalMass_le_one hh
  have hp := pow_le_pow_left₀ ha.le hu b
  have hb := one_add_mul_le_pow (a := totalMass h-1) (by linarith : -2 ≤ totalMass h-1) b
  simp only [add_sub_cancel] at hb
  have ht := mul_le_mul_of_nonneg_left (totalMass_tail hh) (Nat.cast_nonneg b : (0 : ℝ) ≤ _)
  simp only [one_pow] at hp
  constructor <;> nlinarith

lemma height_totalMass_power_loss {b : ℕ} (hb : 2 ≤ b) :
    0 ≤ 1-(totalMass (height b))^b ∧
      1-(totalMass (height b))^b ≤ 2*(b : ℝ)^(-(1/8 : ℝ)) := by
  have hb1 : 1 ≤ (b : ℝ) := by exact_mod_cast (show 1 ≤ b by omega)
  have hb0 : 0 < (b : ℝ) := by exact_mod_cast (show 0 < b by omega)
  have hh : 0 < height b := heightR_pos (by exact_mod_cast (show 1 < b by omega))
  have ht := totalMass_power_loss hh b
  have he : Real.exp (-(height b^2)/2) = (b : ℝ)^(-(9/8 : ℝ)) := by
    calc
      _ = Real.exp (-(heightR (b : ℝ)^2)*(1/2)) := by change Real.exp (-(heightR (b : ℝ)^2)/2) = _; congr 1; ring
      _ = (b : ℝ)^(-(9/4 : ℝ)*(1/2)) := heightR_exp hb1 (1/2)
      _ = _ := by norm_num
  rw [he] at ht
  have hm : (b : ℝ)*(b : ℝ)^(-(9/8 : ℝ)) = (b : ℝ)^(-(1/8 : ℝ)) := by
    calc
      _ = (b : ℝ)^(1 : ℝ)*(b : ℝ)^(-(9/8 : ℝ)) := by rw [Real.rpow_one]
      _ = (b : ℝ)^((1 : ℝ)-(9/8 : ℝ)) := by rw [sub_eq_add_neg, Real.rpow_add hb0]
      _ = _ := by norm_num
  exact ⟨ht.1, by simpa only [mul_assoc, hm] using ht.2⟩

lemma eventually_height_prime : ∀ᶠ b : ℕ in atTop, ∃ p : ℕ, p.Prime ∧
    (b : ℝ)*logMean (height b)-4*(b : ℝ)^(56/100 : ℝ) ≤ Real.log p ∧
    Real.log p ≤ (b : ℝ)*logMean (height b)-3*(b : ℝ)^(56/100 : ℝ) := by
  exact tendsto_natCast_atTop_atTop.eventually
    (eventually_block_prime (logMean_tendsto.comp heightR_tendsto))




end SingleLatticeCovering.Folded


namespace SingleLatticeCovering.Folded
open Real Filter Topology Asymptotics

lemma eventually_logpow_bound {s c : ℝ} (r : ℝ) (hs : 0 < s) (hc : 0 < c) :
    ∀ᶠ b : ℝ in atTop, (Real.log b)^r ≤ c*b^s := by
  filter_upwards [(isLittleO_log_rpow_rpow_atTop r hs).bound hc,
    eventually_ge_atTop (1 : ℝ)] with b hb hb1
  simpa only [Real.norm_eq_abs, abs_of_nonneg (Real.rpow_nonneg (Real.log_nonneg hb1) _),
    abs_of_nonneg (Real.rpow_nonneg (le_trans (by norm_num) hb1) _)] using hb

lemma eventually_height_bound {s c : ℝ} (hs : 0 < s) (hc : 0 < c) :
    ∀ᶠ b : ℝ in atTop, heightR b ≤ c*b^s := by
  filter_upwards [eventually_logpow_bound (1 : ℝ) hs (div_pos hc (by norm_num : (0 : ℝ) < 3/2)),
    Real.tendsto_log_atTop.eventually (eventually_ge_atTop (1 : ℝ))] with b hb hl
  rw [Real.rpow_one] at hb
  have hsqrt : heightR b ≤ (3/2 : ℝ)*Real.log b := by
    unfold heightR
    apply (Real.sqrt_le_iff).mpr
    constructor
    · positivity
    · nlinarith [sq_nonneg (Real.log b-1)]
  nlinarith

lemma eventually_height_square_le : ∀ᶠ b : ℝ in atTop, heightR b^2 ≤ b := by
  filter_upwards [eventually_logpow_bound (1 : ℝ) (by norm_num : (0 : ℝ) < 1)
    (by norm_num : (0 : ℝ) < 4/9), eventually_ge_atTop (1 : ℝ)] with b hb hb1
  rw [Real.rpow_one, Real.rpow_one] at hb
  rw [heightR_sq hb1]
  linarith

lemma eventually_central_mean : ∀ᶠ b : ℝ in atTop,
    2*b^(70/100 : ℝ) ≤ b*Real.exp (-(heightR b^2)/8)/(heightR b*Real.sqrt (2*Real.pi)) := by
  have hc : 0 < 1/(2*Real.sqrt (2*Real.pi)) := by positivity
  filter_upwards [eventually_height_bound (by norm_num : (0 : ℝ) < 3/160) hc,
    eventually_gt_atTop (1 : ℝ)] with b hb hb1
  have hb0 : 0 < b := by linarith
  have hh := heightR_pos hb1
  have hexp : Real.exp (-(heightR b^2)/8) = b^(-(9/32 : ℝ)) := by
    calc
      _ = Real.exp (-(heightR b^2)*(1/8)) := by congr 1; ring
      _ = b^(-(9/4 : ℝ)*(1/8)) := heightR_exp hb1.le (1/8)
      _ = _ := by norm_num
  rw [hexp, le_div_iff₀ (by positivity)]
  have hh' : 2*(heightR b*Real.sqrt (2*Real.pi)) ≤ b^(3/160 : ℝ) := by
    have hs : 0 < Real.sqrt (2*Real.pi) := by positivity
    have ht := (le_div_iff₀ (show (0 : ℝ) < 2*Real.sqrt (2*Real.pi) by positivity)).mp
      (show heightR b ≤ b^(3/160 : ℝ)/(2*Real.sqrt (2*Real.pi)) by simpa only [one_div, div_eq_mul_inv, mul_comm, one_mul] using hb)
    nlinarith
  have hm := mul_le_mul_of_nonneg_left hh' (Real.rpow_nonneg hb0.le (70/100 : ℝ))
  have he : b^(70/100 : ℝ)*b^(3/160 : ℝ) = b*b^(-(9/32 : ℝ)) := by
    calc
      _ = b^((70/100 : ℝ)+3/160) := (Real.rpow_add hb0 _ _).symm
      _ = b^((1 : ℝ)+(-(9/32 : ℝ))) := by congr 1; norm_num
      _ = _ := by rw [Real.rpow_add hb0, Real.rpow_one]
  rw [he] at hm
  nlinarith

lemma eventually_log_variance_tail : ∀ᶠ b : ℝ in atTop,
    b*((Real.log 2+heightR b^2/8)/2)^2/((1/2 : ℝ)*b^(56/100 : ℝ))^2 ≤ b^(-(1/20 : ℝ)) := by
  filter_upwards [eventually_logpow_bound (2 : ℝ) (by norm_num : (0 : ℝ) < 7/100)
    (by norm_num : (0 : ℝ) < 1/4), eventually_ge_atTop (2 : ℝ)] with b hb hb2
  have hb0 : 0 < b := by linarith
  have hb1 : 1 ≤ b := by linarith
  have hl := Real.log_le_log (by norm_num : (0 : ℝ) < 2) hb2
  have hl0 := Real.log_nonneg hb1
  have hl2 : 0 ≤ Real.log 2 := Real.log_nonneg (by norm_num)
  rw [Real.rpow_two] at hb
  have hsq : ((Real.log 2+heightR b^2/8)/2)^2 ≤ (Real.log b)^2 := by
    rw [heightR_sq hb1]
    apply pow_le_pow_left₀ (by positivity)
    linarith
  have hr2 : (b^(56/100 : ℝ))^2 = b^(112/100 : ℝ) := by
    rw [←Real.rpow_natCast, ←Real.rpow_mul hb0.le]
    norm_num
  have he : b^(-(1/20 : ℝ))*((1/2 : ℝ)*b^(56/100 : ℝ))^2 = (1/4 : ℝ)*b*b^(7/100 : ℝ) := by
    rw [mul_pow, hr2]
    have hpow : b^(-(1/20 : ℝ))*b^(112/100 : ℝ) = b*b^(7/100 : ℝ) := by
      calc
        _ = b^(-(1/20 : ℝ)+(112/100 : ℝ)) := (Real.rpow_add hb0 _ _).symm
        _ = b^((1 : ℝ)+(7/100 : ℝ)) := by congr 1; norm_num
        _ = _ := by rw [Real.rpow_add hb0, Real.rpow_one]
    nlinarith
  apply (div_le_iff₀ (by positivity)).mpr
  rw [he]
  nlinarith [mul_le_mul_of_nonneg_left (hsq.trans hb) hb0.le]



end SingleLatticeCovering.Folded



end
end
end
end
end
end
end

end OAI