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

import OAI.Geometry.LatticeCovering.GaussianSmoothing

namespace OAI

section
noncomputable section
noncomputable section
open MeasureTheory Filter Set
open scoped Topology
noncomputable section

namespace SingleLatticeCovering.Prekopa
open MeasureTheory Set Filter
open scoped ENNReal Topology BigOperators

lemma integral_RV_zero (f : RV 0 → ℝ) : (∫ x, f x)=f 0 := by
  rw [Measure.volume_pi_eq_dirac (0 : RV 0), integral_dirac]

lemma cons_weighted {d : ℕ} (a b x y : ℝ) (u v : RV d) :
    Fin.cons (a*x+b*y) (a•u+b•v) = a•Fin.cons x u+b•Fin.cons y v := by
  ext i
  refine Fin.cases ?_ (fun j => ?_) i <;> rfl




theorem gaussian_dominated_integral (d : ℕ) {f g h : RV d → ℝ}
    (fc : Continuous f) (gc : Continuous g) (hc : Continuous h)
    (fp : ∀ x, 0 < f x) (gp : ∀ x, 0 < g x) (hp : ∀ x, 0 < h x)
    (fb : GaussianBound f) (gb : GaussianBound g) (hb : GaussianBound h)
    {a b : ℝ} (ha : 0 < a) (hb' : 0 < b) (hab : a+b=1)
    (hfg : ∀ x y, f x^a*g y^b ≤ h (a•x+b•y)) :
    (∫ x, f x)^a*(∫ y, g y)^b ≤ ∫ z, h z := by
  induction d with
  | zero =>
    simp only [integral_RV_zero]
    have H := hfg 0 0
    simpa only [smul_zero,add_zero] using H
  | succ d ih =>
    have hm : ∀ y z : RV d,
        (marginalOne f y)^a*(marginalOne g z)^b ≤ marginalOne h (a•y+b•z) := by
      intro y z
      apply positive_integral
        (fc.comp (show Continuous (fun t : ℝ => Fin.cons t y) by fun_prop))
        (gc.comp (show Continuous (fun t : ℝ => Fin.cons t z) by fun_prop))
        (fun t => fp (Fin.cons t y)) (fun t => gp (Fin.cons t z))
        (fb.integrable_slice fc _) (gb.integrable_slice gc _) (hb.integrable_slice hc _)
        (fun t => (hp _).le) ha hb' hab
      intro t u
      simpa only [cons_weighted,Function.comp_def,id_eq] using hfg (Fin.cons t y) (Fin.cons u z)
    have H := ih (fb.continuous_marginalOne fc) (gb.continuous_marginalOne gc)
      (hb.continuous_marginalOne hc) (marginalOne_positive fb fc fp)
      (marginalOne_positive gb gc gp) (marginalOne_positive hb hc hp)
      (fb.for_marginalOne fc) (gb.for_marginalOne gc) (hb.for_marginalOne hc) hm
    simpa only [integral_marginalOne (fb.integrable fc),integral_marginalOne (gb.integrable gc),
      integral_marginalOne (hb.integrable hc)] using H


end SingleLatticeCovering.Prekopa

noncomputable section
namespace SingleLatticeCovering.Prekopa
open MeasureTheory Set Filter Metric
open scoped ENNReal Topology BigOperators

lemma sum_sq_le_norm_sq (d : ℕ) (x : RV d) :
    (∑ i, (x i)^2) ≤ (d : ℝ)*‖x‖^2 := by
  calc
    _ ≤ ∑ _ : Fin d, ‖x‖^2 := by
      apply Finset.sum_le_sum
      intro i _
      have hi := norm_le_pi_norm x i
      simpa only [Real.norm_eq_abs,sq_abs] using pow_le_pow_left₀ (norm_nonneg (x i)) hi 2
    _ = _ := by simp

def softIndicator {d : ℕ} (K : Set (RV d)) (t : ℝ) (x : RV d) : ℝ :=
  Real.exp (-t*(infDist x K)^2)

lemma softIndicator_positive {d : ℕ} (K : Set (RV d)) (t : ℝ) (x : RV d) :
    0 < softIndicator K t x := Real.exp_pos _

lemma continuous_softIndicator {d : ℕ} (K : Set (RV d)) (t : ℝ) :
    Continuous (softIndicator K t) := by
  unfold softIndicator
  exact Real.continuous_exp.comp (continuous_const.mul ((continuous_infDist_pt K).pow 2))

lemma softIndicator_gaussianBound {d : ℕ} {K : Set (RV d)} (hK : IsCompact K)
    (hne : K.Nonempty) {t : ℝ} (ht : 0 < t) : GaussianBound (softIndicator K t) := by
  obtain ⟨R,hR,hb⟩ := hK.isBounded.exists_pos_norm_le
  refine ⟨Real.exp (t*R^2),t/(2*((d : ℝ)+1)),Real.exp_pos _,by positivity,?_⟩
  intro x
  obtain ⟨u,hu,he⟩ := hK.exists_infDist_eq_dist hne x
  have hn : ‖x‖ ≤ infDist x K+R := by
    calc
      ‖x‖ ≤ ‖x-u‖+‖u‖ := by simpa only [add_comm] using norm_le_insert' x u
      _ ≤ infDist x K+R := by rw [he,dist_eq_norm]; exact add_le_add_right (hb u hu) _
  have hs : ‖x‖^2 ≤ 2*((infDist x K)^2+R^2) := by
    have hn' := pow_le_pow_left₀ (norm_nonneg x) hn 2
    nlinarith [sq_nonneg (infDist x K-R)]
  have hs' : (∑ i, (x i)^2) ≤ 2*((d : ℝ)+1)*((infDist x K)^2+R^2) := by
    calc
      _ ≤ (d : ℝ)*‖x‖^2 := sum_sq_le_norm_sq d x
      _ ≤ (d : ℝ)*(2*((infDist x K)^2+R^2)) := mul_le_mul_of_nonneg_left hs (by positivity)
      _ ≤ _ := by nlinarith [sq_nonneg (infDist x K),sq_nonneg R]
  rw [abs_of_pos (softIndicator_positive K t x),softIndicator,gaussianKernel,←Real.exp_add]
  apply Real.exp_le_exp.mpr
  have hd : 0 < 2*((d : ℝ)+1) := by positivity
  have hm := mul_le_mul_of_nonneg_left hs' (div_nonneg ht.le hd.le)
  field_simp at hm ⊢
  nlinarith

lemma infDist_weighted {d : ℕ} {A B C : Set (RV d)}
    (hA : IsCompact A) (hB : IsCompact B) (hneA : A.Nonempty) (hneB : B.Nonempty)
    {a b : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b)
    (hABC : ∀ u ∈ A, ∀ v ∈ B, a•u+b•v ∈ C) (x y : RV d) :
    infDist (a•x+b•y) C ≤ a*infDist x A+b*infDist y B := by
  obtain ⟨u,hu,heu⟩ := hA.exists_infDist_eq_dist hneA x
  obtain ⟨v,hv,hev⟩ := hB.exists_infDist_eq_dist hneB y
  calc
    _ ≤ dist (a•x+b•y) (a•u+b•v) := infDist_le_dist_of_mem (hABC u hu v hv)
    _ = ‖a•(x-u)+b•(y-v)‖ := by rw [dist_eq_norm]; congr 1; module
    _ ≤ ‖a•(x-u)‖+‖b•(y-v)‖ := norm_add_le _ _
    _ = _ := by rw [norm_smul,norm_smul,Real.norm_eq_abs,Real.norm_eq_abs,
      abs_of_nonneg ha,abs_of_nonneg hb,heu,hev,dist_eq_norm,dist_eq_norm]

lemma softIndicator_weighted {d : ℕ} {A B C : Set (RV d)}
    (hA : IsCompact A) (hB : IsCompact B) (hneA : A.Nonempty) (hneB : B.Nonempty)
    {a b t : ℝ} (ha : 0 ≤ a) (hb : 0 ≤ b) (hab : a+b=1) (ht : 0 ≤ t)
    (hABC : ∀ u ∈ A, ∀ v ∈ B, a•u+b•v ∈ C) (x y : RV d) :
    (softIndicator A t x)^a*(softIndicator B t y)^b ≤ softIndicator C t (a•x+b•y) := by
  have H := infDist_weighted hA hB hneA hneB ha hb hABC x y
  have hsq : (infDist (a•x+b•y) C)^2 ≤ a*(infDist x A)^2+b*(infDist y B)^2 := by
    have HH := pow_le_pow_left₀ (infDist_nonneg : 0 ≤ infDist (a•x+b•y) C) H 2
    have hm := mul_nonneg (mul_nonneg ha hb) (sq_nonneg (infDist x A-infDist y B))
    nlinarith [sq_nonneg (a*infDist x A+b*infDist y B),sq_nonneg (infDist x A),sq_nonneg (infDist y B)]
  simp only [softIndicator,←Real.exp_mul,←Real.exp_add]
  apply Real.exp_le_exp.mpr
  nlinarith [mul_nonneg ht (sub_nonneg.mpr hsq)]



end SingleLatticeCovering.Prekopa

namespace SingleLatticeCovering.Prekopa
open MeasureTheory Set Filter Metric
open scoped ENNReal Topology BigOperators

lemma softIndicator_tendsto {d : ℕ} {K : Set (RV d)} (hK : IsClosed K)
    (hne : K.Nonempty) (x : RV d) :
    Tendsto (fun n : ℕ => softIndicator K ((n : ℝ)+1) x) atTop
      (𝓝 (K.indicator (fun _ => (1:ℝ)) x)) := by
  by_cases hx : x ∈ K
  · simp only [softIndicator,infDist_zero_of_mem hx,zero_pow (by omega : 2 ≠ 0),
      mul_zero,Real.exp_zero,Set.indicator_of_mem hx]
    exact tendsto_const_nhds
  · rw [Set.indicator_of_notMem hx]
    have hd : 0 < (infDist x K)^2 := sq_pos_of_pos ((hK.notMem_iff_infDist_pos hne).mp hx)
    have hq : Real.exp (-(infDist x K)^2)<1 := Real.exp_lt_one_iff.mpr (neg_neg_of_pos hd)
    have H := (tendsto_pow_atTop_nhds_zero_of_lt_one (Real.exp_pos (-(infDist x K)^2)).le hq).mul_const
      (Real.exp (-(infDist x K)^2))
    simp only [zero_mul] at H
    convert H using 1
    ext n
    rw [softIndicator,←Real.exp_nat_mul,←Real.exp_add]
    congr 1
    ring

lemma softIndicator_antitone {d : ℕ} (K : Set (RV d)) (x : RV d) :
    Antitone (fun t : ℝ => softIndicator K t x) := by
  intro t u htu
  apply Real.exp_le_exp.mpr
  exact mul_le_mul_of_nonneg_right (neg_le_neg htu) (sq_nonneg _)

lemma softIndicator_integral_tendsto {d : ℕ} {K : Set (RV d)} (hK : IsCompact K)
    (hne : K.Nonempty) :
    Tendsto (fun n : ℕ => ∫ x, softIndicator K ((n : ℝ)+1) x) atTop
      (𝓝 (volume K).toReal) := by
  have H := tendsto_integral_of_dominated_convergence (softIndicator K 1)
    (fun n => (continuous_softIndicator K ((n : ℝ)+1)).aestronglyMeasurable)
    ((softIndicator_gaussianBound hK hne zero_lt_one).integrable (continuous_softIndicator K 1))
    (fun n => Filter.Eventually.of_forall (fun x => by
      rw [Real.norm_eq_abs,abs_of_pos (softIndicator_positive K _ x)]
      exact softIndicator_antitone K x (by nlinarith [Nat.cast_nonneg (α := ℝ) n] : (1:ℝ) ≤ (n : ℝ)+1)))
    (Filter.Eventually.of_forall (softIndicator_tendsto hK.isClosed hne))
  simpa only [integral_indicator hK.measurableSet,integral_const,smul_eq_mul,mul_one,measureReal_def,Measure.restrict_apply_univ] using H




theorem compact_volume {d : ℕ} {A B C : Set (RV d)}
    (hA : IsCompact A) (hB : IsCompact B) (hC : IsCompact C)
    {a b : ℝ} (ha : 0 < a) (hb : 0 < b) (hab : a+b=1)
    (hABC : ∀ u ∈ A, ∀ v ∈ B, a•u+b•v ∈ C) :
    ((volume A).toReal)^a*((volume B).toReal)^b ≤ (volume C).toReal := by
  rcases A.eq_empty_or_nonempty with rfl | hneA
  · simp only [measure_empty,ENNReal.toReal_zero,Real.zero_rpow (ne_of_gt ha),zero_mul]
    exact ENNReal.toReal_nonneg
  rcases B.eq_empty_or_nonempty with rfl | hneB
  · simp only [measure_empty,ENNReal.toReal_zero,Real.zero_rpow (ne_of_gt hb),mul_zero]
    exact ENNReal.toReal_nonneg
  have hneC : C.Nonempty := by
    obtain ⟨u,hu⟩ := hneA
    obtain ⟨v,hv⟩ := hneB
    exact ⟨a•u+b•v,hABC u hu v hv⟩
  have hpoint : ∀ n : ℕ,
      (∫ x, softIndicator A ((n : ℝ)+1) x)^a*
      (∫ x, softIndicator B ((n : ℝ)+1) x)^b ≤ ∫ x, softIndicator C ((n : ℝ)+1) x := by
    intro n
    have hn : 0 < (n : ℝ)+1 := by positivity
    apply gaussian_dominated_integral d (continuous_softIndicator _ _) (continuous_softIndicator _ _)
      (continuous_softIndicator _ _) (softIndicator_positive _ _) (softIndicator_positive _ _)
      (softIndicator_positive _ _) (softIndicator_gaussianBound hA hneA hn)
      (softIndicator_gaussianBound hB hneB hn) (softIndicator_gaussianBound hC hneC hn) ha hb hab
    exact softIndicator_weighted hA hB hneA hneB ha.le hb.le hab hn.le hABC
  exact le_of_tendsto_of_tendsto
    (((Real.continuous_rpow_const ha.le).tendsto _).comp (softIndicator_integral_tendsto hA hneA) |>.mul
      (((Real.continuous_rpow_const hb.le).tendsto _).comp (softIndicator_integral_tendsto hB hneB)))
    (softIndicator_integral_tendsto hC hneC) (Filter.Eventually.of_forall hpoint)


end SingleLatticeCovering.Prekopa




namespace SingleLatticeCovering.Prekopa
open MeasureTheory Set Filter Metric Sections Isotropization
open scoped ENNReal Topology BigOperators




theorem logConcave_section_volume {m D : ℕ} {K : Set (RV m × E D)}
    (hK : IsCompact K) (hconv : Convex ℝ K) :
    LogConcave (fun y => (volume (fiber K y)).toReal) := by
  refine ⟨fun _ => ENNReal.toReal_nonneg,fun x y a b ha hb hab => ?_⟩
  apply compact_volume (fiber_compact hK x) (fiber_compact hK y)
    (fiber_compact hK (a•x+b•y)) ha hb hab
  intro u hu v hv
  have H := hconv hu hv ha.le hb.le hab
  exact H

lemma LogConcave.const_mul {D : ℕ} {f : E D → ℝ} (hf : LogConcave f)
    {c : ℝ} (hc : 0 ≤ c) : LogConcave (fun x => c*f x) := by
  refine ⟨fun x => mul_nonneg hc (hf.1 x),fun x y a b ha hb hab => ?_⟩
  rcases hc.eq_or_lt with rfl | hc
  · simp only [zero_mul,Real.zero_rpow (ne_of_gt ha),Real.zero_rpow (ne_of_gt hb),le_refl]
  · rw [Real.mul_rpow hc.le (hf.1 x),Real.mul_rpow hc.le (hf.1 y)]
    calc
      c^a*f x^a*(c^b*f y^b) = (c^a*c^b)*(f x^a*f y^b) := by ring
      _ = c*(f x^a*f y^b) := by rw [←Real.rpow_add hc,hab,Real.rpow_one]
      _ ≤ c*f (a•x+b•y) := mul_le_mul_of_nonneg_left (hf.2 x y a b ha hb hab) hc.le



theorem logConcave_canonical_density {m D : ℕ} {K : Set (RV m × E D)}
    (hK : IsCompact K) (hconv : Convex ℝ K) :
    LogConcave (fun y => ((volume K)⁻¹).toReal*(volume (fiber K y)).toReal) :=
  LogConcave.const_mul (logConcave_section_volume hK hconv) ENNReal.toReal_nonneg



end SingleLatticeCovering.Prekopa

namespace SingleLatticeCovering.Prekopa
open MeasureTheory Set Filter
open scoped ENNReal Topology

def ScalarLogConcave (f : ℝ → ℝ) : Prop :=
  (∀ t, 0 ≤ f t) ∧ ∀ u v a b : ℝ, 0 < a → 0 < b → a+b=1 →
    f u^a*f v^b ≤ f (a*u+b*v)

def linearCap {d : ℕ} (K : Set (RV d)) (L : RV d →L[ℝ] ℝ) (t : ℝ) : Set (RV d) :=
  K ∩ {x | t ≤ L x}

lemma linearCap_compact {d : ℕ} {K : Set (RV d)} (hK : IsCompact K)
    (L : RV d →L[ℝ] ℝ) (t : ℝ) : IsCompact (linearCap K L t) :=
  hK.inter_right (isClosed_le continuous_const L.continuous)

theorem scalarLogConcave_cap_volume {d : ℕ} {K : Set (RV d)} (hK : IsCompact K)
    (hconv : Convex ℝ K) (L : RV d →L[ℝ] ℝ) :
    ScalarLogConcave (fun t => (volume (linearCap K L t)).toReal) := by
  refine ⟨fun _ => ENNReal.toReal_nonneg,fun u v a b ha hb hab => ?_⟩
  apply compact_volume (linearCap_compact hK L u) (linearCap_compact hK L v)
    (linearCap_compact hK L (a*u+b*v)) ha hb hab
  intro x hx y hy
  refine ⟨hconv hx.1 hy.1 ha.le hb.le hab,?_⟩
  change a*u+b*v ≤ L (a•x+b•y)
  simp only [map_add,map_smul,smul_eq_mul]
  exact add_le_add (mul_le_mul_of_nonneg_left hx.2 ha.le) (mul_le_mul_of_nonneg_left hy.2 hb.le)

lemma ScalarLogConcave.const_mul {f : ℝ → ℝ} (hf : ScalarLogConcave f)
    {c : ℝ} (hc : 0 ≤ c) : ScalarLogConcave (fun t => c*f t) := by
  refine ⟨fun t => mul_nonneg hc (hf.1 t),fun u v a b ha hb hab => ?_⟩
  rcases hc.eq_or_lt with rfl | hc
  · simp only [zero_mul,Real.zero_rpow (ne_of_gt ha),Real.zero_rpow (ne_of_gt hb),le_refl]
  rw [Real.mul_rpow hc.le (hf.1 u),Real.mul_rpow hc.le (hf.1 v)]
  calc
    c^a*f u^a*(c^b*f v^b) = (c^a*c^b)*(f u^a*f v^b) := by ring
    _ = c*(f u^a*f v^b) := by rw [←Real.rpow_add hc,hab,Real.rpow_one]
    _ ≤ c*f (a*u+b*v) := mul_le_mul_of_nonneg_left (hf.2 u v a b ha hb hab) hc.le

lemma ScalarLogConcave.log_interpolation {f : ℝ → ℝ} (hf : ScalarLogConcave f)
    {u v a b : ℝ} (hu : 0 < f u) (hv : 0 < f v)
    (ha : 0 < a) (hb : 0 < b) (hab : a+b=1) :
    a*Real.log (f u)+b*Real.log (f v) ≤ Real.log (f (a*u+b*v)) := by
  have hp : 0 < f u^a*f v^b := mul_pos (Real.rpow_pos_of_pos hu _) (Real.rpow_pos_of_pos hv _)
  have H := Real.log_le_log hp (hf.2 u v a b ha hb hab)
  rwa [Real.log_mul (ne_of_gt (Real.rpow_pos_of_pos hu _)) (ne_of_gt (Real.rpow_pos_of_pos hv _)),
    Real.log_rpow hu,Real.log_rpow hv] at H



theorem ScalarLogConcave.exponential_tail {f : ℝ → ℝ} (hf : ScalarLogConcave f)
    (hle : ∀ t, f t ≤ 1) (hleft : (3:ℝ)/4 ≤ f (-2)) (hright : f 2 ≤ (1:ℝ)/4)
    {t : ℝ} (ht : 0 ≤ t) : f t ≤ Real.exp (1-t/16) := by
  have _ := ht
  by_cases ht2 : t ≤ 2
  · exact (hle t).trans (Real.one_le_exp (by linarith))
  have ht2 : 2 < t := lt_of_not_ge ht2
  rcases (hf.1 t).eq_or_lt with hzero | hpos
  · rw [←hzero]; exact (Real.exp_pos _).le
  have hleftpos : 0 < f (-2) := by linarith
  let a := (t-2)/(t+2)
  let b := 4/(t+2)
  have htp : 0 < t+2 := by linarith
  have ha : 0 < a := div_pos (by linarith) htp
  have hb : 0 < b := div_pos (by norm_num) htp
  have hab : a+b=1 := by dsimp [a,b]; field_simp; ring
  have hinter : a*(-2)+b*t=2 := by dsimp [a,b]; field_simp; ring
  have H := hf.log_interpolation hleftpos hpos ha hb hab
  rw [hinter] at H
  have hl : -(1:ℝ)/2 ≤ Real.log (f (-2)) := by
    have A := Real.one_sub_inv_le_log_of_pos (show (0:ℝ) < 3/4 by norm_num)
    have B := Real.log_le_log (show (0:ℝ) < 3/4 by norm_num) hleft
    norm_num at A
    linarith
  have h2pos : 0 < f 2 := by
    have HH := hf.2 (-2) t a b ha hb hab
    rw [hinter] at HH
    exact (mul_pos (Real.rpow_pos_of_pos hleftpos _) (Real.rpow_pos_of_pos hpos _)).trans_le HH
  have hr : Real.log (f 2) ≤ -(3:ℝ)/4 := by
    have A := Real.log_le_log h2pos hright
    have B := Real.log_le_sub_one_of_pos (show (0:ℝ) < 1/4 by norm_num)
    linarith
  have H' : a*(-(1:ℝ)/2)+b*Real.log (f t) ≤ -(3:ℝ)/4 := by
    have A := mul_le_mul_of_nonneg_left hl ha.le
    linarith
  have H'' := mul_le_mul_of_nonneg_right H' htp.le
  have haeq : a*(t+2)=t-2 := div_mul_cancel₀ _ (ne_of_gt htp)
  have hbeq : b*(t+2)=4 := div_mul_cancel₀ _ (ne_of_gt htp)
  have hcalc : (a*(-(1:ℝ)/2)+b*Real.log (f t))*(t+2)=
      (t-2)*(-(1:ℝ)/2)+4*Real.log (f t) := by
    calc
      _ = (a*(t+2))*(-(1:ℝ)/2)+(b*(t+2))*Real.log (f t) := by ring
      _ = _ := by rw [haeq,hbeq]
  rw [hcalc] at H''
  have hlog : Real.log (f t) ≤ 1-t/16 := by linarith
  simpa only [Real.exp_log hpos] using Real.exp_le_exp.mpr hlog



end SingleLatticeCovering.Prekopa

namespace SingleLatticeCovering.Prekopa
open MeasureTheory Set Filter
open scoped Topology

lemma right_derivative_nonpos_of_max {F : ℝ → ℝ} {A : ℝ}
    (hF : HasDerivAt F A 0) (hmax : ∀ t ∈ Ioo (0:ℝ) 1, F t ≤ F 0) : A ≤ 0 := by
  apply le_of_tendsto hF.tendsto_slope_zero_right
  have hnear : ∀ᶠ t : ℝ in 𝓝[>] 0, t < 1 := nhdsWithin_le_nhds (Iio_mem_nhds (show (0:ℝ) < 1 by norm_num))
  filter_upwards [self_mem_nhdsWithin,hnear] with t ht ht1
  simp only [zero_add,smul_eq_mul]
  exact mul_nonpos_of_nonneg_of_nonpos (inv_nonneg.mpr (le_of_lt ht)) (sub_nonpos.mpr (hmax t ⟨ht,ht1⟩))



theorem ScalarLogConcave.log_bound_at_weighted_mode {φ : ℝ → ℝ}
    (hφ : ScalarLogConcave φ) {m : ℕ} {r₀ r : ℝ} (hr₀ : 0 < r₀) (hr : 0 < r)
    (hφ₀ : 0 < φ r₀) (hφr : 0 < φ r)
    (hmax : ∀ s : ℝ, 0 < s → s^m*φ s ≤ r₀^m*φ r₀) :
    Real.log (φ r)-Real.log (φ r₀) ≤ -(m:ℝ)*(r-r₀)/r₀ := by
  let F : ℝ → ℝ := fun t => (m:ℝ)*Real.log ((1-t)*r₀+t*r)+
    (1-t)*Real.log (φ r₀)+t*Real.log (φ r)
  have hdlin : HasDerivAt (fun t : ℝ => (1-t)*r₀+t*r) (r-r₀) 0 := by
    convert! (((hasDerivAt_const (0:ℝ) (1:ℝ)).sub (hasDerivAt_id (0:ℝ))).mul_const r₀).add
      ((hasDerivAt_id (0:ℝ)).mul_const r) using 1 ;       simp only [zero_sub,neg_one_mul,one_mul] ; ring
  have hdlog := hdlin.log (by simpa using ne_of_gt hr₀)
  have hd : HasDerivAt F ((m:ℝ)*(r-r₀)/r₀-Real.log (φ r₀)+Real.log (φ r)) 0 := by
    convert! ((hdlog.const_mul (m:ℝ)).add
      (((hasDerivAt_const (0:ℝ) (1:ℝ)).sub (hasDerivAt_id (0:ℝ))).mul_const (Real.log (φ r₀)))).add
      ((hasDerivAt_id (0:ℝ)).mul_const (Real.log (φ r))) using 1 ;       simp only [sub_zero,one_mul,zero_mul,add_zero,zero_sub,neg_one_mul] ; ring
  have hFmax : ∀ t ∈ Ioo (0:ℝ) 1, F t ≤ F 0 := by
    intro t ht
    let z := (1-t)*r₀+t*r
    have hz : 0 < z := add_pos (mul_pos (by linarith [ht.2]) hr₀) (mul_pos ht.1 hr)
    have hinter := hφ.log_interpolation hφ₀ hφr (show 0 < 1-t by linarith [ht.2]) ht.1 (by ring)
    change (1-t)*Real.log (φ r₀)+t*Real.log (φ r) ≤ Real.log (φ z) at hinter
    have hφz : 0 < φ z := by
      have H := hφ.2 r₀ r (1-t) t (by linarith [ht.2]) ht.1 (by ring)
      exact (mul_pos (Real.rpow_pos_of_pos hφ₀ _) (Real.rpow_pos_of_pos hφr _)).trans_le H
    have H := Real.log_le_log (mul_pos (pow_pos hz _) hφz) (hmax z hz)
    rw [Real.log_mul (ne_of_gt (pow_pos hz _)) (ne_of_gt hφz),
      Real.log_mul (ne_of_gt (pow_pos hr₀ _)) (ne_of_gt hφ₀),Real.log_pow,Real.log_pow] at H
    dsimp [F]
    simp only [sub_zero,one_mul,zero_mul,add_zero]
    change (m:ℝ)*Real.log z+((1-t)*Real.log (φ r₀))+t*Real.log (φ r) ≤ _
    linarith
  have H := right_derivative_nonpos_of_max hd hFmax
  rw [neg_mul,neg_div]
  linarith

def shellRate (u : ℝ) : ℝ := u-1-Real.log u



theorem ScalarLogConcave.weighted_mode_envelope {φ : ℝ → ℝ}
    (hφ : ScalarLogConcave φ) {m : ℕ} {r₀ r : ℝ} (hr₀ : 0 < r₀) (hr : 0 < r)
    (hφ₀ : 0 < φ r₀)
    (hmax : ∀ s : ℝ, 0 < s → s^m*φ s ≤ r₀^m*φ r₀) :
    r^m*φ r ≤ (r₀^m*φ r₀)*Real.exp (-(m:ℝ)*shellRate (r/r₀)) := by
  rcases (hφ.1 r).eq_or_lt with hz | hp
  · rw [←hz,mul_zero]; positivity
  have H := hφ.log_bound_at_weighted_mode hr₀ hr hφ₀ hp hmax
  have hlog : Real.log (r^m*φ r) ≤ Real.log (r₀^m*φ r₀)-(m:ℝ)*shellRate (r/r₀) := by
    rw [Real.log_mul (ne_of_gt (pow_pos hr _)) (ne_of_gt hp),
      Real.log_mul (ne_of_gt (pow_pos hr₀ _)) (ne_of_gt hφ₀),Real.log_pow,Real.log_pow]
    rw [shellRate,Real.log_div (ne_of_gt hr) (ne_of_gt hr₀)]
    have he : (r-r₀)/r₀=r/r₀-1 := by field_simp
    rw [neg_mul,neg_div,mul_div_assoc,he] at H
    nlinarith
  have HE := Real.exp_le_exp.mpr hlog
  rw [Real.exp_log (mul_pos (pow_pos hr _) hp),Real.exp_sub,
    Real.exp_log (mul_pos (pow_pos hr₀ _) hφ₀),div_eq_mul_inv,←Real.exp_neg] at HE
  simpa only [neg_mul] using HE


end SingleLatticeCovering.Prekopa

namespace SingleLatticeCovering.Prekopa
open MeasureTheory Set Filter
open scoped Topology

lemma shellRate_ge_sqrt_sq {u : ℝ} (hu : 0 < u) : (Real.sqrt u-1)^2 ≤ shellRate u := by
  have H := Real.log_le_sub_one_of_pos (Real.sqrt_pos.mpr hu)
  rw [Real.log_sqrt hu.le] at H
  dsimp [shellRate]
  nlinarith [Real.sq_sqrt hu.le]

lemma shellRate_ge_sq_div_nine {u : ℝ} (hu : 0 < u) (hu2 : u ≤ 2) :
    (u-1)^2/9 ≤ shellRate u := by
  have hs := Real.sqrt_nonneg u
  have hs2 : Real.sqrt u ≤ 2 := by nlinarith [Real.sq_sqrt hu.le]
  have he : (u-1)^2=(Real.sqrt u-1)^2*(Real.sqrt u+1)^2 := by
    calc
      _ = ((Real.sqrt u)^2-1)^2 := by rw [Real.sq_sqrt hu.le]
      _ = _ := by ring
  have hsq : (Real.sqrt u+1)^2 ≤ 9 := by nlinarith
  have hm := mul_le_mul_of_nonneg_left hsq (sq_nonneg (Real.sqrt u-1))
  rw [←he] at hm
  nlinarith [shellRate_ge_sqrt_sq hu]

lemma shellRate_support {u a : ℝ} (hu : 0 < u) (ha : 0 < a) :
    shellRate a+(1-a⁻¹)*(u-a) ≤ shellRate u := by
  have H := Real.log_le_sub_one_of_pos (div_pos hu ha)
  rw [Real.log_div (ne_of_gt hu) (ne_of_gt ha)] at H
  have he : (1-a⁻¹)*(u-a)=u-a-u/a+1 := by field_simp; ring
  rw [he]
  dsimp [shellRate]
  linarith

lemma shellRate_upper_tail {ε u : ℝ} (hε : 0 < ε) (hε1 : ε ≤ 1) (hu : 1+ε ≤ u) :
    ε^2/9+(ε/2)*(u-(1+ε)) ≤ shellRate u := by
  have ha : 0 < 1+ε := by linarith
  have hs := shellRate_support (show 0 < u by linarith) ha
  have hb := shellRate_ge_sq_div_nine ha (show 1+ε ≤ 2 by linarith)
  have hc : ε/2 ≤ 1-(1+ε)⁻¹ := by
    have he : (1-(1+ε)⁻¹)*(1+ε)=ε := by
      rw [sub_mul,one_mul,inv_mul_cancel₀ (ne_of_gt ha)]
      ring
    apply (mul_le_mul_iff_left₀ ha).mp
    nlinarith
  have hm := mul_le_mul_of_nonneg_right hc (sub_nonneg.mpr hu)
  nlinarith

lemma shellRate_lower_tail {ε u : ℝ} (hε : 0 < ε) (hε1 : ε < 1)
    (hu : 0 < u) (hu1 : u ≤ 1-ε) :
    ε^2/9+(ε/2)*((1-ε)-u) ≤ shellRate u := by
  have ha : 0 < 1-ε := by linarith
  have hs := shellRate_support hu ha
  have hb := shellRate_ge_sq_div_nine ha (show 1-ε ≤ 2 by linarith)
  have hc : 1-(1-ε)⁻¹ ≤ -ε/2 := by
    have he : (1-(1-ε)⁻¹)*(1-ε) = -ε := by
      rw [sub_mul,one_mul,inv_mul_cancel₀ (ne_of_gt ha)]
      ring
    apply (mul_le_mul_iff_left₀ ha).mp
    nlinarith
  have hm := mul_le_mul_of_nonpos_right hc (sub_nonpos.mpr hu1)
  nlinarith



end SingleLatticeCovering.Prekopa

namespace SingleLatticeCovering.Prekopa
open MeasureTheory Set Filter
open scoped Topology

lemma integral_exp_shift_Ioi {a : ℝ} (ha : 0 < a) (c : ℝ) :
    (∫ r : ℝ in Ioi c, Real.exp (-a*(r-c)))=a⁻¹ := by
  have he (r : ℝ) : Real.exp (-a*(r-c))=Real.exp (a*c)*Real.exp (-a*r) := by
    rw [←Real.exp_add]; congr 1; ring
  simp_rw [he]
  rw [integral_const_mul,integral_exp_mul_Ioi (by linarith)]
  rw [neg_div_neg_eq,div_eq_mul_inv,←mul_assoc,←Real.exp_add]
  simp

lemma integral_exp_shift_Iic {a : ℝ} (ha : 0 < a) (c : ℝ) :
    (∫ r : ℝ in Iic c, Real.exp (a*(r-c)))=a⁻¹ := by
  have he (r : ℝ) : Real.exp (a*(r-c))=Real.exp (-a*c)*Real.exp (a*r) := by
    rw [←Real.exp_add]; congr 1; ring
  simp_rw [he]
  rw [integral_const_mul,integral_exp_mul_Iic ha]
  rw [div_eq_mul_inv,←mul_assoc,←Real.exp_add]
  simp

lemma integrableOn_exp_shift_Ioi {a : ℝ} (ha : 0 < a) (c : ℝ) :
    IntegrableOn (fun r : ℝ => Real.exp (-a*(r-c))) (Ioi c) volume := by
  have he (r : ℝ) : Real.exp (-a*(r-c))=Real.exp (a*c)*Real.exp (-a*r) := by
    rw [←Real.exp_add]; congr 1; ring
  simp_rw [he]
  exact (integrableOn_exp_mul_Ioi (by linarith) c).const_mul _

lemma integrableOn_exp_shift_Iic {a : ℝ} (ha : 0 < a) (c : ℝ) :
    IntegrableOn (fun r : ℝ => Real.exp (a*(r-c))) (Iic c) volume := by
  have he (r : ℝ) : Real.exp (a*(r-c))=Real.exp (-a*c)*Real.exp (a*r) := by
    rw [←Real.exp_add]; congr 1; ring
  simp_rw [he]
  exact (integrableOn_exp_mul_Iic ha c).const_mul _

lemma ScalarLogConcave.upper_shell_envelope {φ : ℝ → ℝ}
    (hφ : ScalarLogConcave φ) {m : ℕ} {r₀ ε r : ℝ}
    (hr₀ : 0 < r₀) (hε : 0 < ε) (hε1 : ε ≤ 1) (hφ₀ : 0 < φ r₀)
    (hmax : ∀ s : ℝ, 0 < s → s^m*φ s ≤ r₀^m*φ r₀)
    (hr : (1+ε)*r₀ ≤ r) :
    r^m*φ r ≤ (r₀^m*φ r₀*Real.exp (-(m:ℝ)*ε^2/9))*
      Real.exp (-((m:ℝ)*ε/(2*r₀))*(r-(1+ε)*r₀)) := by
  have hrp : 0 < r := (mul_pos (by linarith) hr₀).trans_le hr
  have hu : 1+ε ≤ r/r₀ := (le_div_iff₀ hr₀).mpr hr
  have H := mul_le_mul_of_nonpos_left (shellRate_upper_tail hε hε1 hu)
    (neg_nonpos.mpr (Nat.cast_nonneg m))
  have E := hφ.weighted_mode_envelope hr₀ hrp hφ₀ hmax
  apply E.trans
  rw [mul_assoc (r₀^m*φ r₀),←Real.exp_add]
  apply mul_le_mul_of_nonneg_left _ (mul_nonneg (pow_nonneg hr₀.le _) hφ₀.le)
  apply Real.exp_le_exp.mpr
  exact H.trans_eq (by field_simp; ring)

lemma ScalarLogConcave.lower_shell_envelope {φ : ℝ → ℝ}
    (hφ : ScalarLogConcave φ) {m : ℕ} {r₀ ε r : ℝ}
    (hr₀ : 0 < r₀) (hε : 0 < ε) (hε1 : ε < 1) (hφ₀ : 0 < φ r₀)
    (hmax : ∀ s : ℝ, 0 < s → s^m*φ s ≤ r₀^m*φ r₀)
    (hr : 0 < r) (hr1 : r ≤ (1-ε)*r₀) :
    r^m*φ r ≤ (r₀^m*φ r₀*Real.exp (-(m:ℝ)*ε^2/9))*
      Real.exp (((m:ℝ)*ε/(2*r₀))*(r-(1-ε)*r₀)) := by
  have hu : r/r₀ ≤ 1-ε := (div_le_iff₀ hr₀).mpr hr1
  have H := mul_le_mul_of_nonpos_left (shellRate_lower_tail hε hε1 (div_pos hr hr₀) hu)
    (neg_nonpos.mpr (Nat.cast_nonneg m))
  have E := hφ.weighted_mode_envelope hr₀ hr hφ₀ hmax
  apply E.trans
  rw [mul_assoc (r₀^m*φ r₀),←Real.exp_add]
  apply mul_le_mul_of_nonneg_left _ (mul_nonneg (pow_nonneg hr₀.le _) hφ₀.le)
  apply Real.exp_le_exp.mpr
  exact H.trans_eq (by field_simp; ring)

lemma ScalarLogConcave.upper_shell_integral {φ : ℝ → ℝ}
    (hφ : ScalarLogConcave φ) {m : ℕ} (hm : 0 < m) {r₀ ε : ℝ}
    (hr₀ : 0 < r₀) (hε : 0 < ε) (hε1 : ε ≤ 1) (hφ₀ : 0 < φ r₀)
    (hmax : ∀ s : ℝ, 0 < s → s^m*φ s ≤ r₀^m*φ r₀)
    (hi : IntegrableOn (fun r => r^m*φ r) (Ioi 0) volume) :
    (∫ r in Ioi ((1+ε)*r₀), r^m*φ r) ≤
      (r₀^m*φ r₀*Real.exp (-(m:ℝ)*ε^2/9))*((m:ℝ)*ε/(2*r₀))⁻¹ := by
  have ha : 0 < (m:ℝ)*ε/(2*r₀) := by positivity
  calc
    _ ≤ ∫ r in Ioi ((1+ε)*r₀),
        (r₀^m*φ r₀*Real.exp (-(m:ℝ)*ε^2/9))*Real.exp (-((m:ℝ)*ε/(2*r₀))*(r-(1+ε)*r₀)) := by
      have hs : Ioi ((1+ε)*r₀) ⊆ Ioi 0 := by
        intro r hr
        exact ((mul_pos (by linarith) hr₀).trans hr)
      apply integral_mono_ae (hi.mono_set hs) ((integrableOn_exp_shift_Ioi ha _).const_mul _)
      filter_upwards [ae_restrict_mem measurableSet_Ioi] with r hr
      exact hφ.upper_shell_envelope hr₀ hε hε1 hφ₀ hmax (le_of_lt hr)
    _ = _ := by rw [integral_const_mul,integral_exp_shift_Ioi ha]


lemma ScalarLogConcave.lower_shell_integral {φ : ℝ → ℝ}
    (hφ : ScalarLogConcave φ) {m : ℕ} (hm : 0 < m) {r₀ ε : ℝ}
    (hr₀ : 0 < r₀) (hε : 0 < ε) (hε1 : ε < 1) (hφ₀ : 0 < φ r₀)
    (hmax : ∀ s : ℝ, 0 < s → s^m*φ s ≤ r₀^m*φ r₀)
    (hi : IntegrableOn (fun r => r^m*φ r) (Ioi 0) volume) :
    (∫ r in Ioc 0 ((1-ε)*r₀), r^m*φ r) ≤
      (r₀^m*φ r₀*Real.exp (-(m:ℝ)*ε^2/9))*((m:ℝ)*ε/(2*r₀))⁻¹ := by
  have ha : 0 < (m:ℝ)*ε/(2*r₀) := by positivity
  let F : ℝ → ℝ := fun r => (r₀^m*φ r₀*Real.exp (-(m:ℝ)*ε^2/9))*
    Real.exp (((m:ℝ)*ε/(2*r₀))*(r-(1-ε)*r₀))
  have hF : IntegrableOn F (Iic ((1-ε)*r₀)) volume :=
    (integrableOn_exp_shift_Iic ha _).const_mul _
  calc
    _ ≤ ∫ r in Ioc 0 ((1-ε)*r₀), F r := by
      apply integral_mono_ae (hi.mono_set Ioc_subset_Ioi_self) (hF.mono_set Ioc_subset_Iic_self)
      filter_upwards [ae_restrict_mem measurableSet_Ioc] with r hr
      exact hφ.lower_shell_envelope hr₀ hε hε1 hφ₀ hmax hr.1 hr.2
    _ ≤ ∫ r in Iic ((1-ε)*r₀), F r := by
      apply setIntegral_mono_set hF
      · exact Filter.Eventually.of_forall (fun r => by dsimp [F]; positivity)
      · exact Filter.Eventually.of_forall Ioc_subset_Iic_self
    _ = _ := by dsimp [F]; rw [integral_const_mul,integral_exp_shift_Iic ha]

lemma radial_integral_lower {φ : ℝ → ℝ} {m : ℕ} {r₀ : ℝ}
    (hr₀ : 0 < r₀) (hφ : ∀ r, 0 ≤ φ r)
    (hmono : ∀ r ∈ Ioc 0 r₀, φ r₀ ≤ φ r)
    (hi : IntegrableOn (fun r => r^m*φ r) (Ioi 0) volume) :
    r₀^m*φ r₀*r₀/(m+1:ℝ) ≤ ∫ r in Ioi 0, r^m*φ r := by
  have hpoly : IntegrableOn (fun r : ℝ => r^m*φ r₀) (Ioc 0 r₀) volume :=
    (Continuous.integrableOn_Icc (by fun_prop)).mono_set Ioc_subset_Icc_self
  have hcalc : (∫ r in Ioc 0 r₀, r^m*φ r₀)=r₀^m*φ r₀*r₀/(m+1:ℝ) := by
    rw [←intervalIntegral.integral_of_le hr₀.le,intervalIntegral.integral_mul_const,integral_pow]
    simp only [zero_pow (Nat.succ_ne_zero m),sub_zero,pow_succ]
    ring
  rw [←hcalc]
  calc
    _ ≤ ∫ r in Ioc 0 r₀, r^m*φ r := by
      apply integral_mono_ae hpoly (hi.mono_set Ioc_subset_Ioi_self)
      filter_upwards [ae_restrict_mem measurableSet_Ioc] with r hr
      exact mul_le_mul_of_nonneg_left (hmono r hr) (pow_nonneg hr.1.le _)
    _ ≤ _ := by
      apply setIntegral_mono_set hi
      · filter_upwards [ae_restrict_mem measurableSet_Ioi] with r hr
        exact mul_nonneg (pow_nonneg hr.le _) (hφ r)
      · exact Filter.Eventually.of_forall Ioc_subset_Ioi_self


theorem ScalarLogConcave.shell_integral_bound {φ : ℝ → ℝ}
    (hφ : ScalarLogConcave φ) {m : ℕ} (hm : 0 < m) {r₀ ε : ℝ}
    (hr₀ : 0 < r₀) (hε : 0 < ε) (hε1 : ε < 1) (hφ₀ : 0 < φ r₀)
    (hmax : ∀ s : ℝ, 0 < s → s^m*φ s ≤ r₀^m*φ r₀)
    (hmono : ∀ r ∈ Ioc 0 r₀, φ r₀ ≤ φ r)
    (hi : IntegrableOn (fun r => r^m*φ r) (Ioi 0) volume) :
    (∫ r in Ioc 0 ((1-ε)*r₀), r^m*φ r)+
      (∫ r in Ioi ((1+ε)*r₀), r^m*φ r) ≤
      (4*((m:ℝ)+1)/((m:ℝ)*ε)*Real.exp (-(m:ℝ)*ε^2/9))*(∫ r in Ioi 0, r^m*φ r) := by
  have HL := hφ.lower_shell_integral hm hr₀ hε hε1 hφ₀ hmax hi
  have HU := hφ.upper_shell_integral hm hr₀ hε hε1.le hφ₀ hmax hi
  have HN := radial_integral_lower hr₀ hφ.1 hmono hi
  have hm' : 0 < (m:ℝ) := Nat.cast_pos.mpr hm
  have HN' : r₀^m*φ r₀*r₀ ≤ ((m:ℝ)+1)*(∫ r in Ioi 0, r^m*φ r) := by
    have H := (div_le_iff₀ (show 0 < (m:ℝ)+1 by positivity)).mp HN
    linarith
  have he : 2*((r₀^m*φ r₀*Real.exp (-(m:ℝ)*ε^2/9))*((m:ℝ)*ε/(2*r₀))⁻¹)=
      (4/((m:ℝ)*ε)*Real.exp (-(m:ℝ)*ε^2/9))*(r₀^m*φ r₀*r₀) := by field_simp; ring
  have HE := mul_le_mul_of_nonneg_left HN' (show 0 ≤ 4/((m:ℝ)*ε)*Real.exp (-(m:ℝ)*ε^2/9) by positivity)
  calc
    _ ≤ 2*((r₀^m*φ r₀*Real.exp (-(m:ℝ)*ε^2/9))*((m:ℝ)*ε/(2*r₀))⁻¹) := by linarith
    _ = _ := he
    _ ≤ _ := HE
    _ = _ := by ring

lemma exists_weighted_mode {φ : ℝ → ℝ} {m : ℕ} (hm : 0 < m)
    (hc : Continuous φ) (hp : 0 < φ 1)
    (ht : Tendsto (fun r : ℝ => r^m*φ r) atTop (𝓝 0)) :
    ∃ r₀ : ℝ, 0 < r₀ ∧ 0 < φ r₀ ∧
      ∀ r : ℝ, 0 < r → r^m*φ r ≤ r₀^m*φ r₀ := by
  have hev : ∀ᶠ r : ℝ in atTop, r^m*φ r < φ 1 := ht (Iio_mem_nhds hp)
  obtain ⟨R,hR⟩ := eventually_atTop.mp hev
  let B := max R 1
  have hB : (1:ℝ) ≤ B := le_max_right _ _
  have hcont : Continuous (fun r : ℝ => r^m*φ r) := by fun_prop
  obtain ⟨r₀,hr₀,hmax⟩ := isCompact_Icc.exists_isMaxOn (nonempty_Icc.mpr (by linarith : (0:ℝ) ≤ B)) hcont.continuousOn
  have hbase : φ 1 ≤ r₀^m*φ r₀ := by
    simpa only [Set.mem_ofPred_eq,one_pow,one_mul] using hmax (show (1:ℝ) ∈ Icc 0 B from ⟨by norm_num,hB⟩)
  have hpos : 0 < r₀ := by
    rcases hr₀.1.eq_or_lt with hz | hz
    · subst r₀
      simp only [zero_pow (Nat.ne_of_gt hm),zero_mul] at hbase
      linarith
    · exact hz
  have hφpos : 0 < φ r₀ := (mul_pos_iff_of_pos_left (pow_pos hpos m)).mp (hp.trans_le hbase)
  refine ⟨r₀,hpos,hφpos,fun r hr => ?_⟩
  by_cases hrB : r ≤ B
  · exact hmax ⟨hr.le,hrB⟩
  · exact (hR r ((le_max_left R 1).trans (le_of_not_ge hrB))).le.trans hbase







end SingleLatticeCovering.Prekopa


end
end
end
end
end

end OAI