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

import OAI.Geometry.LatticeCovering.Model

namespace OAI


section





section



noncomputable section
open scoped BigOperators
open Real

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

def gamma1 (x : ℝ) : ℝ := Real.exp (-(x^2)/2) / Real.sqrt (2*Real.pi)
def gamma (x : ι → ℝ) : ℝ := ∏ j, gamma1 (x j)
def height (b : ℕ) : ℝ := Real.sqrt ((9/4 : ℝ)*Real.log (b : ℝ))
def density (h t : ℝ) : ℝ := h*gamma1 (h*t)+h*gamma1 (h*(t-1))
def folded (h : ℝ) (t : ι → ℝ) : ℝ := ∏ j, density h (t j)
def bitValue (e : Bool) : ℝ := if e then 1 else 0
def probability (h t : ℝ) (e : Bool) : ℝ :=
  h*gamma1 (h*(t-bitValue e))/density h t
def wordMass (h : ℝ) (t : ι → ℝ) (e : ι → Bool) : ℝ := ∏ j, probability h (t j) (e j)
def atom (h : ℝ) (t : ι → ℝ) (e : ι → Bool) : ℝ :=
  h^Fintype.card ι * gamma (fun j => h*(t j-bitValue (e j)))

def alpha : ℝ := (1+Real.exp 1)⁻¹

lemma gamma1_pos (x : ℝ) : 0 < gamma1 x :=
  div_pos (Real.exp_pos _) (Real.sqrt_pos.mpr (mul_pos (by norm_num) Real.pi_pos))

lemma density_pos {h : ℝ} (hh : 0 < h) (t : ℝ) : 0 < density h t :=
  add_pos (mul_pos hh (gamma1_pos _)) (mul_pos hh (gamma1_pos _))

lemma folded_pos {h : ℝ} (hh : 0 < h) (t : ι → ℝ) : 0 < folded h t :=
  Finset.prod_pos (fun _ _ => density_pos hh _)

lemma alpha_pos : 0 < alpha := by unfold alpha; positivity
lemma alpha_lt_one : alpha < 1 := by
  apply (inv_lt_one₀ (by positivity : (0 : ℝ) < 1+exp 1)).mpr
  linarith [Real.exp_pos (1 : ℝ)]

lemma probability_sum {h : ℝ} (hh : 0 < h) (t : ℝ) :
    probability h t false + probability h t true = 1 := by
  simp only [probability, bitValue, Bool.false_eq_true, ↓reduceIte, sub_zero,
    ← add_div]
  exact div_self (density_pos hh t).ne'

lemma probability_pos {h : ℝ} (hh : 0 < h) (t : ℝ) (e : Bool) :
    0 < probability h t e :=
  div_pos (mul_pos hh (gamma1_pos _)) (density_pos hh _)

lemma probability_le_one {h : ℝ} (hh : 0 < h) (t : ℝ) (e : Bool) :
    probability h t e ≤ 1 := by
  have hs := probability_sum hh t
  have hf := (probability_pos hh t false).le
  have ht := (probability_pos hh t true).le
  cases e <;> linarith

lemma wordMass_sum [DecidableEq ι] {h : ℝ} (hh : 0 < h) (t : ι → ℝ) :
    (∑ e : ι → Bool, wordMass h t e) = 1 := by
  unfold wordMass
  rw [← Fintype.prod_sum]
  have hs (j : ι) : (∑ e : Bool, probability h (t j) e) = 1 := by
    rw [Fintype.sum_bool]
    linarith [probability_sum hh (t j)]
  simp only [hs, Finset.prod_const_one]

lemma folded_identity {h : ℝ} (hh : 0 < h) (t : ι → ℝ) (e : ι → Bool) :
    atom h t e = folded h t * wordMass h t e := by
  have ha : atom h t e = ∏ j, h*gamma1 (h*(t j-bitValue (e j))) := by
    simp [atom, gamma, Finset.prod_mul_distrib]
  rw [ha, folded, wordMass, ← Finset.prod_mul_distrib]
  apply Finset.prod_congr rfl
  intro j _
  simp only [probability]
  field_simp [(density_pos hh (t j)).ne']

lemma gaussian_ratio (h t : ℝ) :
    gamma1 (h*t) = Real.exp (h^2*(1/2-t))*gamma1 (h*(t-1)) := by
  have he : -(h*t)^2/2 = h^2*(1/2-t) + -(h*(t-1))^2/2 := by ring
  simp only [gamma1, he, Real.exp_add]
  ring

lemma probability_true_logistic {h : ℝ} (hh : 0 < h) (t : ℝ) :
    probability h t true = (1+Real.exp (h^2*(1/2-t)))⁻¹ := by
  have hg := (gamma1_pos (h*(t-1))).ne'
  unfold probability density
  simp only [bitValue, ↓reduceIte]
  rw [gaussian_ratio h t]
  field_simp
  ring

lemma one_sub_logistic (s : ℝ) :
    1-(1+Real.exp s)⁻¹ = (1+Real.exp (-s))⁻¹ := by
  rw [Real.exp_neg]
  field_simp
  ring

lemma logistic_lower {s : ℝ} (hs : s ≤ 1) : alpha ≤ (1+Real.exp s)⁻¹ := by
  simpa only [alpha, one_div] using
    one_div_le_one_div_of_le (by positivity : (0 : ℝ) < 1+exp s)
      (add_le_add_right (Real.exp_le_exp.mpr hs) 1)

lemma probability_central {h t : ℝ} (hh : 0 < h)
    (ht : |t-1/2| ≤ (h^2)⁻¹) (e : Bool) :
    alpha ≤ probability h t e ∧ probability h t e ≤ 1-alpha := by
  have hh2 : 0 < h^2 := sq_pos_of_pos hh
  have hprod := mul_le_mul_of_nonneg_left ht hh2.le
  rw [mul_inv_cancel₀ hh2.ne'] at hprod
  have hab := abs_le.mp ht
  have h1 : h^2*(1/2-t) ≤ 1 := by
    calc _ ≤ h^2*|t-1/2| := mul_le_mul_of_nonneg_left (by linarith [neg_le_abs (t-1/2)] : 1/2-t ≤ |t-1/2|) hh2.le
         _ ≤ 1 := hprod
  have h2 : -(h^2*(1/2-t)) ≤ 1 := by
    calc _ ≤ h^2*|t-1/2| := by nlinarith [le_abs_self (t-1/2)]
         _ ≤ 1 := hprod
  have hp := logistic_lower h1
  have hn := logistic_lower h2
  rw [← probability_true_logistic hh t] at hp
  rw [← one_sub_logistic, ← probability_true_logistic hh t] at hn
  have hs := probability_sum hh t
  cases e <;> constructor <;> linarith

lemma wordMass_le_exp_card {h : ℝ} (hh : 0 < h) (t : ι → ℝ) (e : ι → Bool)
    (S : Finset ι) (hS : ∀ j ∈ S, |t j-1/2| ≤ (h^2)⁻¹) :
    wordMass h t e ≤ Real.exp (-alpha*(S.card : ℝ)) := by
  classical
  have he : 1-alpha ≤ Real.exp (-alpha) := by
    have h := Real.add_one_le_exp (-alpha)
    linarith
  calc
    _ ≤ ∏ j : ι, Real.exp (if j ∈ S then -alpha else 0) := by
      apply Finset.prod_le_prod₀ (fun j _ => (probability_pos hh _ _).le)
      intro j _
      by_cases hj : j ∈ S
      · simp only [hj, ↓reduceIte]
        exact (probability_central hh (hS j hj) _).2.trans he
      · simp only [hj, ↓reduceIte, Real.exp_zero]
        exact probability_le_one hh _ _
    _ = _ := by
      rw [← Real.exp_sum]
      congr 1
      simp [Finset.sum_ite_mem, mul_comm]



end SingleLatticeCovering.Folded

namespace SingleLatticeCovering.Folded
open MeasureTheory ProbabilityTheory Set


def totalMass (h : ℝ) : ℝ := ∫ t in (0 : ℝ)..1, density h t

def logMean (h : ℝ) : ℝ :=
  (∫ t in (0 : ℝ)..1, density h t*Real.log (density h t))/totalMass h

lemma continuous_gamma1 : Continuous gamma1 := by
  unfold gamma1
  fun_prop

lemma continuous_density (h : ℝ) : Continuous (density h) := by
  unfold density
  exact (continuous_const.mul (continuous_gamma1.comp (continuous_const.mul continuous_id))).add
    (continuous_const.mul (continuous_gamma1.comp (continuous_const.mul (continuous_id.sub continuous_const))))

lemma gamma1_eq_gaussianPDF (x : ℝ) : gamma1 x = gaussianPDFReal 0 1 x := by
  simp only [gaussianPDFReal, NNReal.coe_one, mul_one, sub_zero, gamma1]
  ring

lemma gamma1_even (x : ℝ) : gamma1 (-x) = gamma1 x := by simp [gamma1]

lemma gamma1_int : ∫ x : ℝ, gamma1 x = 1 := by
  simp_rw [gamma1_eq_gaussianPDF]
  exact integral_gaussianPDFReal_eq_one 0 (by norm_num)

lemma gamma1_integrable : Integrable gamma1 := by
  have he : gamma1 = gaussianPDFReal 0 1 := funext gamma1_eq_gaussianPDF
  rw [he]
  exact integrable_gaussianPDFReal _ _

lemma totalMass_eq_integral {h : ℝ} (hh : 0 < h) :
    totalMass h = ∫ x in -h..h, gamma1 x := by
  unfold totalMass density
  rw [intervalIntegral.integral_add]
  · rw [intervalIntegral.integral_const_mul, intervalIntegral.integral_const_mul]
    rw [intervalIntegral.integral_comp_mul_left gamma1 hh.ne']
    have hs : (∫ t in (0 : ℝ)..1, gamma1 (h*(t-1))) =
        h⁻¹ * ∫ x in -h..0, gamma1 x := by
      calc
        _ = ∫ t in (0 : ℝ)..1, (fun u => gamma1 (h*u)) (t-1) := rfl
        _ = ∫ t in (-1 : ℝ)..0, gamma1 (h*t) := by
          simpa using (intervalIntegral.integral_comp_sub_right
            (fun u => gamma1 (h*u)) (a := 0) (b := 1) 1)
        _ = _ := by rw [intervalIntegral.integral_comp_mul_left gamma1 hh.ne']; simp
    rw [hs]
    simp only [mul_zero, mul_one, smul_eq_mul]
    rw [←mul_assoc, mul_inv_cancel₀ hh.ne', one_mul, ←mul_assoc, mul_inv_cancel₀ hh.ne', one_mul]
    rw [add_comm]
    exact intervalIntegral.integral_add_adjacent_intervals
      (continuous_gamma1.intervalIntegrable _ _) (continuous_gamma1.intervalIntegrable _ _)
  · exact (continuous_const.mul (continuous_gamma1.comp (continuous_const.mul continuous_id))).intervalIntegrable _ _
  · exact (continuous_const.mul (continuous_gamma1.comp
      (continuous_const.mul (continuous_id.sub continuous_const)))).intervalIntegrable _ _

lemma totalMass_pos {h : ℝ} (hh : 0 < h) : 0 < totalMass h := by
  unfold totalMass
  apply intervalIntegral.integral_pos
  · norm_num
  · exact (continuous_density h).continuousOn
  · intro x hx
    exact (density_pos hh x).le
  · exact ⟨0, by norm_num, density_pos hh 0⟩

lemma totalMass_le_one {h : ℝ} (hh : 0 < h) : totalMass h ≤ 1 := by
  rw [totalMass_eq_integral hh, intervalIntegral.integral_of_le (by linarith : -h ≤ h)]
  rw [←gamma1_int]
  exact setIntegral_le_integral gamma1_integrable (Filter.Eventually.of_forall (fun x => (gamma1_pos x).le))

lemma gamma1_le_inv_sqrt (x : ℝ) : gamma1 x ≤ (Real.sqrt (2*Real.pi))⁻¹ := by
  unfold gamma1
  apply (div_le_iff₀ (Real.sqrt_pos.mpr (mul_pos (by norm_num) Real.pi_pos))).mpr
  rw [inv_mul_cancel₀ (Real.sqrt_pos.mpr (mul_pos (by norm_num) Real.pi_pos)).ne']
  exact Real.exp_le_one_iff.mpr (by nlinarith [sq_nonneg x])

lemma density_upper {h : ℝ} (hh : 0 ≤ h) (t : ℝ) :
    density h t ≤ 2*h/Real.sqrt (2*Real.pi) := by
  have h0 := mul_le_mul_of_nonneg_left (gamma1_le_inv_sqrt (h*t)) hh
  have h1 := mul_le_mul_of_nonneg_left (gamma1_le_inv_sqrt (h*(t-1))) hh
  unfold density
  rw [div_eq_mul_inv]
  nlinarith

lemma density_lower {h t : ℝ} (hh : 0 < h) (ht : t ∈ Icc 0 1) :
    h/Real.sqrt (2*Real.pi)*Real.exp (-(h^2)/8) ≤ density h t := by
  have hbase {x : ℝ} (hx : |x| ≤ 1/2) :
      h/Real.sqrt (2*Real.pi)*Real.exp (-(h^2)/8) ≤ h*gamma1 (h*x) := by
    have hx' := abs_le.mp hx
    have hs : (h*x)^2 ≤ h^2/4 := by
      have hsq : x^2 ≤ 1/4 := by nlinarith
      nlinarith [mul_le_mul_of_nonneg_left hsq (sq_nonneg h)]
    have he := mul_le_mul_of_nonneg_left (Real.exp_le_exp.mpr (show -(h^2)/8 ≤ -(h*x)^2/2 by nlinarith))
      (show 0 ≤ h/Real.sqrt (2*Real.pi) by positivity)
    simpa only [gamma1, div_mul_eq_mul_div, mul_div_assoc] using he
  by_cases ht2 : t ≤ 1/2
  · have hz := hbase (abs_le.mpr ⟨by linarith [ht.1],ht2⟩)
    exact hz.trans (le_add_of_nonneg_right (mul_nonneg hh.le (gamma1_pos _).le))
  · have hz := hbase (x := t-1) (abs_le.mpr ⟨by linarith,by linarith [ht.2]⟩)
    exact hz.trans (le_add_of_nonneg_left (mul_nonneg hh.le (gamma1_pos _).le))



end SingleLatticeCovering.Folded

namespace SingleLatticeCovering.Folded
open MeasureTheory ProbabilityTheory Set Real

lemma gaussian_subgaussian : HasSubgaussianMGF (fun x : ℝ => x) 1 (gaussianReal 0 1) where
  integrable_exp_mul := integrable_exp_mul_gaussianReal
  mgf_le t := by simp [mgf_fun_id_gaussianReal]

lemma totalMass_eq_probability {h : ℝ} (hh : 0 < h) :
    totalMass h = (gaussianReal 0 1).real (Ioc (-h) h) := by
  rw [Measure.real, gaussianReal_apply_eq_integral 0 (by norm_num)]
  rw [ENNReal.toReal_ofReal (integral_nonneg (fun x => gaussianPDFReal_nonneg 0 1 x))]
  rw [totalMass_eq_integral hh, intervalIntegral.integral_of_le (by linarith : -h ≤ h)]
  exact setIntegral_congr_fun measurableSet_Ioc (fun x _ => gamma1_eq_gaussianPDF x)


lemma totalMass_tail {h : ℝ} (hh : 0 < h) :
    1-totalMass h ≤ 2*Real.exp (-h^2/2) := by
  rw [totalMass_eq_probability hh]
  have hc : (gaussianReal 0 1).real ((Ioc (-h) h)ᶜ) =
      1-(gaussianReal 0 1).real (Ioc (-h) h) := by
    rw [measureReal_compl measurableSet_Ioc]
    simp
  rw [←hc]
  have hs : (Ioc (-h) h)ᶜ ⊆ {x : ℝ | h ≤ -x} ∪ {x : ℝ | h ≤ x} := by
    intro x hx
    simp only [mem_compl_iff, mem_Ioc, not_and_or, not_lt, not_le] at hx
    rcases hx with hx | hx
    · exact Or.inl (by dsimp; linarith)
    · exact Or.inr hx.le
  calc
    _ ≤ (gaussianReal 0 1).real ({x : ℝ | h ≤ -x} ∪ {x : ℝ | h ≤ x}) :=
      measureReal_mono hs
    _ ≤ (gaussianReal 0 1).real {x : ℝ | h ≤ -x} +
        (gaussianReal 0 1).real {x : ℝ | h ≤ x} := measureReal_union_le _ _
    _ ≤ _ := by
      have hl := gaussian_subgaussian.neg.measure_ge_le hh.le
      have hr := gaussian_subgaussian.measure_ge_le hh.le
      simp only [Pi.neg_apply, NNReal.coe_one, mul_one] at hl hr
      linarith

lemma gamma1_second_int : ∫ x : ℝ, gamma1 x * x^2 = 1 := by
  have hv := variance_fun_id_gaussianReal (μ := 0) (v := 1)
  rw [variance_eq_integral (X := fun x : ℝ => x) (by fun_prop)] at hv
  simp only [integral_id_gaussianReal, sub_zero, NNReal.coe_one] at hv
  rw [integral_gaussianReal_eq_integral_smul (by norm_num : (1 : NNReal) ≠ 0)] at hv
  simpa only [←gamma1_eq_gaussianPDF, smul_eq_mul] using hv

lemma gamma1_second_integrable : Integrable (fun x : ℝ => gamma1 x*x^2) := by
  have hi := (integrable_rpow_mul_exp_neg_mul_sq (b := (1/2 : ℝ)) (by norm_num)
    (s := 2) (by norm_num)).div_const (Real.sqrt (2*Real.pi))
  convert hi using 1
  ext x
  rw [Real.rpow_two]
  unfold gamma1
  rw [show -(x^2)/2 = -(1/2 : ℝ)*x^2 by ring]
  ring



end SingleLatticeCovering.Folded

namespace SingleLatticeCovering.Folded
open MeasureTheory ProbabilityTheory Set Real

lemma integral_fold {φ : ℝ → ℝ} (hφ : Continuous φ) {h : ℝ} (hh : 0 < h) :
    (∫ t in (0 : ℝ)..1, h*φ (h*t)+h*φ (h*(t-1))) = ∫ x in -h..h, φ x := by
  rw [intervalIntegral.integral_add]
  · rw [intervalIntegral.integral_const_mul, intervalIntegral.integral_const_mul]
    rw [intervalIntegral.integral_comp_mul_left φ hh.ne']
    have hs : (∫ t in (0 : ℝ)..1, φ (h*(t-1))) = h⁻¹ * ∫ x in -h..0, φ x := by
      calc
        _ = ∫ t in (0 : ℝ)..1, (fun u => φ (h*u)) (t-1) := rfl
        _ = ∫ t in (-1 : ℝ)..0, φ (h*t) := by
          simpa using (intervalIntegral.integral_comp_sub_right
            (fun u => φ (h*u)) (a := 0) (b := 1) 1)
        _ = _ := by rw [intervalIntegral.integral_comp_mul_left φ hh.ne']; simp
    rw [hs]
    simp only [mul_zero, mul_one, smul_eq_mul]
    rw [←mul_assoc, mul_inv_cancel₀ hh.ne', one_mul, ←mul_assoc, mul_inv_cancel₀ hh.ne', one_mul]
    rw [add_comm]
    exact intervalIntegral.integral_add_adjacent_intervals
      (hφ.intervalIntegrable _ _) (hφ.intervalIntegrable _ _)
  · exact (continuous_const.mul (hφ.comp (continuous_const.mul continuous_id))).intervalIntegrable _ _
  · exact (continuous_const.mul (hφ.comp
      (continuous_const.mul (continuous_id.sub continuous_const)))).intervalIntegrable _ _

def foldMoment (h t : ℝ) : ℝ :=
  h*(gamma1 (h*t)*(h*t)^2)+h*(gamma1 (h*(t-1))*(h*(t-1))^2)

lemma continuous_foldMoment (h : ℝ) : Continuous (foldMoment h) := by
  unfold foldMoment
  exact (continuous_const.mul ((continuous_gamma1.comp (continuous_const.mul continuous_id)).mul
    ((continuous_const.mul continuous_id).pow 2))).add
    (continuous_const.mul ((continuous_gamma1.comp
      (continuous_const.mul (continuous_id.sub continuous_const))).mul
      ((continuous_const.mul (continuous_id.sub continuous_const)).pow 2)))

lemma foldMoment_integral_le {h : ℝ} (hh : 0 < h) :
    (∫ t in (0 : ℝ)..1, foldMoment h t) ≤ 1 := by
  unfold foldMoment
  rw [integral_fold (φ := fun x => gamma1 x*x^2)
    (continuous_gamma1.mul (continuous_id.pow 2)) hh,
    intervalIntegral.integral_of_le (by linarith : -h ≤ h), ←gamma1_second_int]
  exact setIntegral_le_integral gamma1_second_integrable
    (Filter.Eventually.of_forall (fun x => mul_nonneg (gamma1_pos x).le (sq_nonneg x)))

lemma log_component {h : ℝ} (hh : 0 < h) (x : ℝ) :
    Real.log (h*gamma1 (h*x)) = Real.log h-Real.log (Real.sqrt (2*Real.pi))-(h*x)^2/2 := by
  rw [Real.log_mul hh.ne' (gamma1_pos _).ne', gamma1,
    Real.log_div (Real.exp_pos _).ne' (Real.sqrt_pos.mpr (mul_pos (by norm_num) Real.pi_pos)).ne',
    Real.log_exp]
  ring

lemma entropy_lower_pointwise {h : ℝ} (hh : 0 < h) (t : ℝ) :
    (Real.log h-Real.log (Real.sqrt (2*Real.pi)))*density h t-foldMoment h t/2 ≤
      density h t*Real.log (density h t) := by
  have hp0 : 0 < h*gamma1 (h*t) := mul_pos hh (gamma1_pos _)
  have hp1 : 0 < h*gamma1 (h*(t-1)) := mul_pos hh (gamma1_pos _)
  have hl0 := Real.log_le_log hp0 (show h*gamma1 (h*t) ≤ density h t by
    unfold density; linarith)
  have hl1 := Real.log_le_log hp1 (show h*gamma1 (h*(t-1)) ≤ density h t by
    unfold density; linarith)
  rw [log_component hh] at hl0 hl1
  have h0 := mul_le_mul_of_nonneg_left hl0 hp0.le
  have h1 := mul_le_mul_of_nonneg_left hl1 hp1.le
  unfold density foldMoment at *
  nlinarith

lemma logMean_upper {h : ℝ} (hh : 0 < h) :
    logMean h ≤ Real.log (2*h/Real.sqrt (2*Real.pi)) := by
  have hc : Continuous (fun t => density h t*Real.log (density h t)) :=
    (continuous_density h).mul ((continuous_density h).log (fun t => (density_pos hh t).ne'))
  have hl : (∫ t in (0 : ℝ)..1, density h t*Real.log (density h t)) ≤
      (∫ t in (0 : ℝ)..1, density h t*Real.log (2*h/Real.sqrt (2*Real.pi))) := by
    apply intervalIntegral.integral_mono_on (by norm_num) (hc.intervalIntegrable _ _)
      (((continuous_density h).mul continuous_const).intervalIntegrable _ _)
    intro t ht
    exact mul_le_mul_of_nonneg_left (Real.log_le_log (density_pos hh t)
      (density_upper hh.le t)) (density_pos hh t).le
  rw [intervalIntegral.integral_mul_const] at hl
  exact (div_le_iff₀ (totalMass_pos hh)).mpr (by simpa [mul_comm, totalMass] using hl)

lemma logMean_lower {h : ℝ} (hh : 0 < h) :
    Real.log h-Real.log (Real.sqrt (2*Real.pi))-1/(2*totalMass h) ≤ logMean h := by
  have hc : Continuous (fun t => density h t*Real.log (density h t)) :=
    (continuous_density h).mul ((continuous_density h).log (fun t => (density_pos hh t).ne'))
  have hl : (∫ t in (0 : ℝ)..1,
      (Real.log h-Real.log (Real.sqrt (2*Real.pi)))*density h t-foldMoment h t/2) ≤
      (∫ t in (0 : ℝ)..1, density h t*Real.log (density h t)) := by
    refine intervalIntegral.integral_mono_on (by norm_num) ?_ (hc.intervalIntegrable _ _) ?_
    · exact ((continuous_const.mul (continuous_density h)).sub
        ((continuous_foldMoment h).div_const 2)).intervalIntegrable _ _
    · intro t ht
      exact entropy_lower_pointwise hh t
  have hi₁ : IntervalIntegrable (fun t =>
      (Real.log h-Real.log (Real.sqrt (2*Real.pi)))*density h t) volume 0 1 :=
    (continuous_const.mul (continuous_density h)).intervalIntegrable _ _
  have hi₂ : IntervalIntegrable (fun t => foldMoment h t/2) volume 0 1 :=
    ((continuous_foldMoment h).div_const 2).intervalIntegrable _ _
  rw [intervalIntegral.integral_sub hi₁ hi₂,
    intervalIntegral.integral_const_mul, intervalIntegral.integral_div] at hl
  have hm := foldMoment_integral_le hh
  apply (le_div_iff₀ (totalMass_pos hh)).mpr
  have he : (Real.log h-Real.log (Real.sqrt (2*Real.pi))-1/(2*totalMass h))*totalMass h =
      (Real.log h-Real.log (Real.sqrt (2*Real.pi)))*totalMass h-1/2 := by
    field_simp [(totalMass_pos hh).ne']
  rw [he]
  dsimp [totalMass] at *
  linarith

lemma logMean_lower_of_half {h : ℝ} (hh : 0 < h) (ha : 1/2 ≤ totalMass h) :
    Real.log h-Real.log (Real.sqrt (2*Real.pi))-1 ≤ logMean h := by
  have hi : 1/(2*totalMass h) ≤ 1 := (div_le_one (by positivity)).mpr (by linarith)
  linarith [logMean_lower hh]



end SingleLatticeCovering.Folded

namespace SingleLatticeCovering.Folded
open MeasureTheory ProbabilityTheory Set Real


def law (h : ℝ) : Measure ℝ :=
  (volume.restrict (Icc (0 : ℝ) 1)).withDensity
    (fun t => ENNReal.ofReal (density h t/totalMass h))

lemma measurable_weight (h : ℝ) :
    Measurable (fun t => ENNReal.ofReal (density h t/totalMass h)) :=
  ((continuous_density h).div_const _).measurable.ennreal_ofReal

lemma integral_law {h : ℝ} (hh : 0 < h) (g : ℝ → ℝ) :
    (∫ t, g t ∂law h) = (∫ t in (0 : ℝ)..1, density h t*g t)/totalMass h := by
  unfold law
  rw [integral_withDensity_eq_integral_toReal_smul (measurable_weight h)
    (Filter.Eventually.of_forall (fun _ => ENNReal.ofReal_lt_top))]
  simp_rw [ENNReal.toReal_ofReal (div_nonneg (density_pos hh _).le (totalMass_pos hh).le),
    smul_eq_mul, div_mul_eq_mul_div]
  rw [integral_div, integral_Icc_eq_integral_Ioc,
    ←intervalIntegral.integral_of_le (by norm_num : (0 : ℝ) ≤ 1)]

lemma law_isProbability {h : ℝ} (hh : 0 < h) : IsProbabilityMeasure (law h) := by
  constructor
  unfold law
  rw [withDensity_apply _ MeasurableSet.univ, Measure.restrict_univ,
    ←ofReal_integral_eq_lintegral_ofReal]
  · rw [integral_div, integral_Icc_eq_integral_Ioc,
      ←intervalIntegral.integral_of_le (by norm_num : (0 : ℝ) ≤ 1)]
    change ENNReal.ofReal (totalMass h/totalMass h) = 1
    rw [div_self (totalMass_pos hh).ne', ENNReal.ofReal_one]
  · exact ((continuous_density h).div_const _).integrableOn_Icc
  · exact Filter.Eventually.of_forall (fun t =>
      div_nonneg (density_pos hh t).le (totalMass_pos hh).le)

lemma law_ae_mem (h : ℝ) : ∀ᵐ t ∂law h, t ∈ Icc (0 : ℝ) 1 := by
  unfold law
  apply (ae_withDensity_iff (measurable_weight h)).mpr
  filter_upwards [ae_restrict_mem measurableSet_Icc] with t ht
  exact fun _ => ht

lemma continuous_integrable_law {h : ℝ} (hh : 0 < h) {g : ℝ → ℝ}
    (hg : Continuous g) : Integrable g (law h) := by
  unfold law
  rw [integrable_withDensity_iff (measurable_weight h)
    (Filter.Eventually.of_forall (fun _ => ENNReal.ofReal_lt_top))]
  simp_rw [ENNReal.toReal_ofReal (div_nonneg (density_pos hh _).le (totalMass_pos hh).le)]
  exact (hg.mul ((continuous_density h).div_const _)).integrableOn_Icc

lemma continuous_log_density {h : ℝ} (hh : 0 < h) :
    Continuous (fun t => Real.log (density h t)) :=
  (continuous_density h).log (fun t => (density_pos hh t).ne')

lemma integral_log_density {h : ℝ} (hh : 0 < h) :
    (∫ t, Real.log (density h t) ∂law h) = logMean h := integral_law hh _

lemma log_density_bounds {h t : ℝ} (hh : 0 < h) (ht : t ∈ Icc 0 1) :
    Real.log (density h t) ∈ Icc
      (Real.log h-Real.log (Real.sqrt (2*Real.pi))-h^2/8)
      (Real.log h-Real.log (Real.sqrt (2*Real.pi))+Real.log 2) := by
  have hs : 0 < Real.sqrt (2*Real.pi) := Real.sqrt_pos.mpr (mul_pos (by norm_num) Real.pi_pos)
  constructor
  · have hl := Real.log_le_log (x := h/Real.sqrt (2*Real.pi)*Real.exp (-h^2/8))
      (by positivity) (density_lower hh ht)
    rw [Real.log_mul (by positivity) (Real.exp_pos _).ne',
      Real.log_div hh.ne' hs.ne', Real.log_exp] at hl
    linarith
  · have hu := Real.log_le_log (density_pos hh t) (density_upper hh.le t)
    rw [Real.log_div (mul_pos (by norm_num) hh).ne' hs.ne',
      Real.log_mul (by norm_num) hh.ne'] at hu
    linarith

lemma log_density_memLp {h : ℝ} (hh : 0 < h) :
    MemLp (fun t => Real.log (density h t)) 2 (law h) := by
  let := law_isProbability hh
  refine memLp_of_bounded
    (a := Real.log h-Real.log (Real.sqrt (2*Real.pi))-h^2/8)
    (b := Real.log h-Real.log (Real.sqrt (2*Real.pi))+Real.log 2)
    ?_ (continuous_log_density hh).aestronglyMeasurable 2
  filter_upwards [law_ae_mem h] with t ht
  exact log_density_bounds hh ht

lemma log_density_variance {h : ℝ} (hh : 0 < h) :
    Var[fun t => Real.log (density h t); law h] ≤ ((Real.log 2+h^2/8)/2)^2 := by
  let := law_isProbability hh
  have hb : ∀ᵐ t ∂law h, Real.log (density h t) ∈ Icc
      (Real.log h-Real.log (Real.sqrt (2*Real.pi))-h^2/8)
      (Real.log h-Real.log (Real.sqrt (2*Real.pi))+Real.log 2) := by
    filter_upwards [law_ae_mem h] with t ht
    exact log_density_bounds hh ht
  convert variance_le_sq_of_bounded hb (continuous_log_density hh).measurable.aemeasurable using 1 ; ring



end SingleLatticeCovering.Folded



noncomputable section
open scoped BigOperators
open MeasureTheory ProbabilityTheory Set
namespace SingleLatticeCovering.Concentration
variable {Ω : Type*} [MeasurableSpace Ω] {μ : Measure Ω}

lemma chebyshev_real [IsFiniteMeasure μ] {X : Ω → ℝ}
    (hX : MemLp X 2 μ) {c : ℝ} (hc : 0 < c) :
    μ.real {ω | c ≤ |X ω-∫ x, X x ∂μ|} ≤ Var[X; μ]/c^2 := by
  have ht := ENNReal.toReal_mono ENNReal.ofReal_ne_top (meas_ge_le_variance_div_sq hX hc)
  rwa [ENNReal.toReal_ofReal (div_nonneg (variance_nonneg X μ) (sq_nonneg c))] at ht

variable {ι : Type*} [Fintype ι]

lemma sum_memLp [IsProbabilityMeasure μ] {X : Ω → ℝ} (hX : MemLp X 2 μ) :
    MemLp (fun ω : ι → Ω => ∑ i, X (ω i)) 2 (Measure.pi (fun _ : ι => μ)) := by
  exact memLp_finsetSum Finset.univ (fun i _ =>
    hX.comp_measurePreserving (measurePreserving_eval (fun _ : ι => μ) i))

lemma sum_mean [IsProbabilityMeasure μ] {X : Ω → ℝ} (hX : Integrable X μ) :
    (∫ ω : ι → Ω, ∑ i, X (ω i) ∂Measure.pi (fun _ : ι => μ)) =
      (Fintype.card ι : ℝ)*(∫ x, X x ∂μ) := by
  rw [integral_finsetSum Finset.univ (fun i _ => integrable_comp_eval hX)]
  simp only [integral_comp_eval (μ := fun _ : ι => μ) hX.aestronglyMeasurable, Finset.sum_const,
    Finset.card_univ, nsmul_eq_mul]

lemma sum_variance [IsProbabilityMeasure μ] {X : Ω → ℝ} (hX : MemLp X 2 μ) :
    Var[fun ω : ι → Ω => ∑ i, X (ω i); Measure.pi (fun _ : ι => μ)] =
      (Fintype.card ι : ℝ)*Var[X; μ] := by
  have he : (∑ i, fun ω : ι → Ω => X (ω i)) = (fun ω : ι → Ω => ∑ i, X (ω i)) := by
    ext ω; simp
  rw [←he]
  simpa only [Finset.sum_const, Finset.card_univ, nsmul_eq_mul]
    using (variance_sum_pi (μ := fun _ : ι => μ) (X := fun _ : ι => X) (fun _ => hX))

lemma sum_chebyshev [IsProbabilityMeasure μ] {X : Ω → ℝ} (hX : MemLp X 2 μ)
    {v c : ℝ} (hv : Var[X; μ] ≤ v) (hc : 0 < c) :
    (Measure.pi (fun _ : ι => μ)).real
      {ω | c ≤ |(∑ i, X (ω i))-(Fintype.card ι : ℝ)*(∫ x, X x ∂μ)|} ≤
        (Fintype.card ι : ℝ)*v/c^2 := by
  have ht := chebyshev_real (sum_memLp (ι := ι) hX) hc
  rw [sum_mean (hX.integrable (by norm_num)), sum_variance hX] at ht
  exact ht.trans (div_le_div_of_nonneg_right (mul_le_mul_of_nonneg_left hv (Nat.cast_nonneg _))
    (sq_nonneg c))

lemma indicator_variance [IsProbabilityMeasure μ] {s : Set Ω} (hs : MeasurableSet s) :
    Var[s.indicator (fun _ => (1 : ℝ)); μ] ≤ μ.real s := by
  have hm : MemLp (s.indicator (fun _ => (1 : ℝ))) 2 μ := (memLp_const 1).indicator hs
  have ht := variance_le_expectation_sq hm.aestronglyMeasurable
  have he : (fun x => (s.indicator (fun _ => (1 : ℝ)) x)^2) = s.indicator (fun _ => (1 : ℝ)) := by
    ext x
    by_cases hx : x ∈ s <;> simp [hx]
  change Var[s.indicator (fun _ => (1 : ℝ)); μ] ≤ ∫ x, (s.indicator (fun _ => (1 : ℝ)) x)^2 ∂μ at ht
  rw [he] at ht
  simpa only [integral_indicator_const (1 : ℝ) hs, smul_eq_mul, mul_one] using ht

lemma count_lower_tail [IsProbabilityMeasure μ] {s : Set Ω} (hs : MeasurableSet s)
    (hp : 0 < (Fintype.card ι : ℝ)*μ.real s) :
    (Measure.pi (fun _ : ι => μ)).real
      {ω | (∑ i, s.indicator (fun _ => (1 : ℝ)) (ω i)) <
        (Fintype.card ι : ℝ)*μ.real s/2} ≤ 4/((Fintype.card ι : ℝ)*μ.real s) := by
  have hm : MemLp (s.indicator (fun _ => (1 : ℝ))) 2 μ := (memLp_const 1).indicator hs
  have ht := sum_chebyshev (ι := ι) hm (indicator_variance hs) (half_pos hp)
  simp only [integral_indicator_const (1 : ℝ) hs, smul_eq_mul, mul_one] at ht
  have hsub : {ω : ι → Ω | (∑ i, s.indicator (fun _ => (1 : ℝ)) (ω i)) <
      (Fintype.card ι : ℝ)*μ.real s/2} ⊆
      {ω | (Fintype.card ι : ℝ)*μ.real s/2 ≤
        |(∑ i, s.indicator (fun _ => (1 : ℝ)) (ω i))-(Fintype.card ι : ℝ)*μ.real s|} := by
    intro ω hω
    have hz := le_abs_self (-((∑ i, s.indicator (fun _ => (1 : ℝ)) (ω i))-
      (Fintype.card ι : ℝ)*μ.real s))
    rw [abs_neg] at hz
    dsimp at hω ⊢
    linarith
  have he : (Fintype.card ι : ℝ)*μ.real s/((Fintype.card ι : ℝ)*μ.real s/2)^2 =
      4/((Fintype.card ι : ℝ)*μ.real s) := by field_simp [hp.ne']; ring
  exact (measureReal_mono hsub).trans (ht.trans_eq he)



end SingleLatticeCovering.Concentration


end
end
end
end

end OAI