lean/OAI/Probability/JammingConcavity/LogHeatCalculus.lean

import Mathlib
import OAI.Probability.JammingConcavity.FiniteRowRecursion

namespace OAI

/-! Log Heat Calculus. -/

noncomputable section

open MeasureTheory ProbabilityTheory Set
open scoped NNReal ENNReal
open Set Filter
open scoped Topology
open MeasureTheory ProbabilityTheory Filter Set
open scoped ENNReal NNReal Topology BigOperators
open MeasureTheory Filter Set
open scoped ENNReal NNReal BigOperators
open MeasureTheory ProbabilityTheory Set Filter
open scoped ENNReal NNReal Topology
open scoped NNReal ENNReal Topology
open MeasureTheory ProbabilityTheory Set Filter
open scoped NNReal ENNReal Topology

namespace MicroscopicJamming

lemma log_heat_calculus {f f₁ f₂ : ℝ → ℝ → ℝ} {T a : ℝ} (ha : a ≠ 0)
    (hf : ∀ x, f T x ≠ 0)
    (hx : ∀ x, HasDerivAt (f T) (f₁ T x) x)
    (hxx : ∀ x, HasDerivAt (f₁ T) (f₂ T x) x)
    (ht : ∀ x, HasDerivAt (fun r => f r x) ((1/2:ℝ)*f₂ T x) T) :
    let g := fun (r x : ℝ) => (1/a)*Real.log (f r x)
    Differentiable ℝ (g T) ∧ Differentiable ℝ (deriv (g T)) ∧
    ∀ x, HasDerivAt (fun r => g r x)
      ((1/2:ℝ)*(deriv (deriv (g T)) x+a*(deriv (g T) x)^2)) T := by
  dsimp only
  let g := fun (r x : ℝ) => (1/a)*Real.log (f r x)
  have hg (x : ℝ) : HasDerivAt (g T) ((1/a)*(f₁ T x/f T x)) x :=
    ((hx x).log (hf x)).const_mul _
  have he : deriv (g T) = fun x => (1/a)*(f₁ T x/f T x) := funext fun x => (hg x).deriv
  have hg' (x : ℝ) : HasDerivAt (deriv (g T))
      ((1/a)*((f₂ T x*f T x-f₁ T x*f₁ T x)/(f T x)^2)) x := by
    rw [he]
    exact ((hxx x).div (hx x) (hf x)).const_mul _
  refine ⟨fun x => (hg x).differentiableAt, fun x => (hg' x).differentiableAt, fun x => ?_⟩
  have htime := ((ht x).log (hf x)).const_mul (1/a)
  have hi : (1/a)*(((1/2:ℝ)*f₂ T x)/f T x) =
      (1/2:ℝ)*(deriv (deriv (g T)) x+a*(deriv (g T) x)^2) := by
    rw [(hg' x).deriv, (hg x).deriv]
    field_simp [ha,hf x]
    ring
  rw [hi] at htime
  exact htime

lemma gaussianHeat_twice_calculus {v v' v'' : ℝ → ℝ}
    (hv : Measurable v) (hv' : Measurable v') (hv'' : Measurable v'')
    (hg : HeatQuadraticGrowth v) (hg' : HeatQuadraticGrowth v') (hg'' : HeatQuadraticGrowth v'')
    (hdv : ∀ x, HasDerivAt v (v' x) x) (hdv' : ∀ x, HasDerivAt v' (v'' x) x)
    {T : ℝ} (hT : 0 < T) :
    Differentiable ℝ (gaussianHeat v T) ∧ Differentiable ℝ (deriv (gaussianHeat v T)) ∧
    ∀ x, HasDerivAt (fun r => gaussianHeat v r x)
      ((1/2:ℝ)*deriv (deriv (gaussianHeat v T)) x) T := by
  have hx := gaussianHeat_space_derivative hv hv' hg hg' hdv T
  have hxx := gaussianHeat_space_derivative hv' hv'' hg' hg'' hdv' T
  have he : deriv (gaussianHeat v T) = gaussianHeat v' T := funext fun x => (hx x).deriv
  refine ⟨fun x => (hx x).differentiableAt, ?_, ?_⟩
  · rw [he]; exact fun x => (hxx x).differentiableAt
  · intro x
    rw [he,(hxx x).deriv]
    exact gaussianHeat_time_derivative hv hv' hv'' hg hg' hg'' hdv hdv' hT x
end MicroscopicJamming

 
open MeasureTheory ProbabilityTheory Set Filter
open scoped NNReal ENNReal Topology

namespace MicroscopicJamming

lemma gaussianHeat_zero (v : ℝ → ℝ) (x : ℝ) : gaussianHeat v 0 x = v x := by
  simp [gaussianHeat]

lemma gaussianRowOperator_zero (a : ℝ) (u : ℝ → ℝ) (x : ℝ) :
    gaussianRowOperator a 0 u x = u x := by
  by_cases ha : a=0
  · simp [gaussianRowOperator,ha,gaussianHeat_zero]
  · simp [gaussianRowOperator,ha,gaussianHeat_zero,Real.log_exp]

lemma gaussianRowOperator_calculus {u : ℝ → ℝ} {A B C κ Q a T : ℝ}
    (hu : RowAnalyticTerminal u A B C κ Q) (ha : 0 ≤ a) (hT : 0 < T) :
    Differentiable ℝ (gaussianRowOperator a T u) ∧
    Differentiable ℝ (deriv (gaussianRowOperator a T u)) ∧
    ∀ x, HasDerivAt (fun r => gaussianRowOperator a r u x)
      ((1/2:ℝ)*(deriv (deriv (gaussianRowOperator a T u)) x+
        a*(deriv (gaussianRowOperator a T u) x)^2)) T := by
  by_cases haz : a=0
  · subst a
    have hd := contDiff_infty_iff_deriv.mp hu.1
    have hd' := contDiff_infty_iff_deriv.mp hd.2
    have hh := gaussianHeat_twice_calculus hu.1.continuous.measurable
      hd.2.continuous.measurable hd'.2.continuous.measurable
      (row_terminal_quadratic_growth hu) (row_terminal_deriv_growth hu)
      (row_terminal_second_growth hu) (fun x => (hd.1 x).hasDerivAt)
      (fun x => (hd'.1 x).hasDerivAt) hT
    have he (r : ℝ) : gaussianRowOperator 0 r u = gaussianHeat u r := by
      funext x; simp [gaussianRowOperator]
    simpa only [he,zero_mul,add_zero] using hh
  · obtain ⟨hm,hm₁,hm₂⟩ := row_exp_measurable hu a
    obtain ⟨hg,hg₁,hg₂⟩ := row_exp_growth hu ha
    obtain ⟨hd,hd₁⟩ := row_exp_derivatives hu a
    have hp (x : ℝ) : 0 < gaussianHeat (fun y => Real.exp (a*u y)) T x :=
      integral_exp_pos (heat_affine_quadratic_integrable hm hg x (Real.sqrt T))
    have hh := log_heat_calculus haz (fun x => (hp x).ne')
      (gaussianHeat_space_derivative hm hm₁ hg hg₁ hd T)
      (gaussianHeat_space_derivative hm₁ hm₂ hg₁ hg₂ hd₁ T)
      (gaussianHeat_time_derivative hm hm₁ hm₂ hg hg₁ hg₂ hd hd₁ hT)
    have he (r : ℝ) : gaussianRowOperator a r u =
        fun x => (1/a)*Real.log (gaussianHeat (fun y => Real.exp (a*u y)) r x) := by
      funext x; simp only [gaussianRowOperator,ite_eq_right haz]
    simpa only [he] using hh

theorem gaussian_cole_hopf : GaussianColeHopfStatement := by
  intro u A B C κ Q hQ hu a ha ha1
  exact ⟨gaussianRowOperator_zero a u,fun T hT _ => gaussianRowOperator_calculus hu ha hT⟩
end MicroscopicJamming

 
 

namespace MicroscopicJamming

def GaussianCurvatureStatement : Prop :=
  ∀ (u : ℝ → ℝ) (A B C κ Q : ℝ), 0 < Q → RowAnalyticTerminal u A B C κ Q →
  ∀ a : ℝ, 0 ≤ a → a ≤ 1 → ∀ T : ℝ, 0 < T → T ≤ Q →
  ∀ x : ℝ, -C ≤ deriv (deriv (gaussianRowOperator a T u)) x ∧
    deriv (deriv (gaussianRowOperator a T u)) x ≤ κ/(1-κ*T)
end MicroscopicJamming

 
open MeasureTheory ProbabilityTheory Set Filter
open scoped NNReal ENNReal Topology

namespace MicroscopicJamming

lemma integral_four_linear {μ : Measure ℝ} {f g h k : ℝ → ℝ}
    (hf : Integrable f μ) (hg : Integrable g μ) (hh : Integrable h μ) (hk : Integrable k μ)
    (a b c d : ℝ) :
    (∫ x,a*f x-b*g x-c*h x+d*k x ∂μ) =
      a*(∫ x,f x ∂μ)-b*(∫ x,g x ∂μ)-c*(∫ x,h x ∂μ)+d*(∫ x,k x ∂μ) := by
  have hfg : Integrable (fun x => a*f x-b*g x) μ := (hf.const_mul a).sub (hg.const_mul b)
  have hfgh : Integrable (fun x => a*f x-b*g x-c*h x) μ := hfg.sub (hh.const_mul c)
  rw [integral_add hfgh (hk.const_mul d),integral_sub hfg (hh.const_mul c),
    integral_sub (hf.const_mul a) (hg.const_mul b),integral_const_mul,
    integral_const_mul,integral_const_mul,integral_const_mul]

lemma integral_three_linear {μ : Measure ℝ} {f g h : ℝ → ℝ}
    (hf : Integrable f μ) (hg : Integrable g μ) (hh : Integrable h μ) (a b c : ℝ) :
    (∫ x,a*f x-b*g x+c*h x ∂μ) =
      a*(∫ x,f x ∂μ)-b*(∫ x,g x ∂μ)+c*(∫ x,h x ∂μ) := by
  have hfg : Integrable (fun x => a*f x-b*g x) μ := (hf.const_mul a).sub (hg.const_mul b)
  rw [integral_add hfg (hh.const_mul c),integral_sub (hf.const_mul a) (hg.const_mul b),
    integral_const_mul,integral_const_mul,integral_const_mul]

lemma weighted_covariance_nonpos {μ : Measure ℝ} {f w : ℝ → ℝ}
    (hw : ∀ x, 0 ≤ w x) (hf : Antitone f)
    (h0 : Integrable w μ) (h1 : Integrable (fun x => x*w x) μ)
    (h2 : Integrable (fun x => f x*w x) μ)
    (h3 : Integrable (fun x => x*f x*w x) μ) :
    (∫ x,w x ∂μ)*(∫ x,x*f x*w x ∂μ) ≤
      (∫ x,f x*w x ∂μ)*(∫ x,x*w x ∂μ) := by
  let Z := ∫ x,w x ∂μ
  let L := ∫ x,x*w x ∂μ
  let U := ∫ x,f x*w x ∂μ
  let K := ∫ x,x*f x*w x ∂μ
  have hi (x : ℝ) : f x*x*Z-f x*L-x*U+K ≤ 0 := by
    have hh : (∫ y, ((f x*x)*w y-f x*(y*w y))-x*(f y*w y)+(y*f y*w y) ∂μ) ≤ 0 := by
      apply integral_nonpos_of_ae
      filter_upwards [] with y
      have hp : (f x-f y)*(x-y) ≤ 0 := by
        rcases le_total x y with hxy|hyx
        · exact mul_nonpos_of_nonneg_of_nonpos (sub_nonneg.mpr (hf hxy)) (sub_nonpos.mpr hxy)
        · exact mul_nonpos_of_nonpos_of_nonneg (sub_nonpos.mpr (hf hyx)) (sub_nonneg.mpr hyx)
      change ((f x*x)*w y-f x*(y*w y))-x*(f y*w y)+(y*f y*w y) ≤ 0
      nlinarith [mul_nonpos_of_nonpos_of_nonneg hp (hw y)]
    have he := integral_four_linear h0 h1 h2 h3 (f x*x) (f x) x 1
    simp only [one_mul] at he
    rw [he] at hh
    exact hh
  have hh : (∫ x, Z*(x*f x*w x)-L*(f x*w x)-U*(x*w x)+K*w x ∂μ) ≤ 0 := by
    apply integral_nonpos_of_ae
    filter_upwards [] with x
    change Z*(x*f x*w x)-L*(f x*w x)-U*(x*w x)+K*w x ≤ 0
    nlinarith [mul_nonpos_of_nonpos_of_nonneg (hi x) (hw x)]
  rw [integral_four_linear h3 h2 h1 h0 Z L U K] at hh
  change Z*K ≤ U*L
  change Z*K-L*U-U*L+K*Z ≤ 0 at hh
  nlinarith

lemma weighted_covariance_upper {μ : Measure ℝ} {f w : ℝ → ℝ} {c : ℝ}
    (hw : ∀ x, 0 ≤ w x) (hf : Antitone (fun x => f x-c*x))
    (h0 : Integrable w μ) (h1 : Integrable (fun x => x*w x) μ)
    (h2 : Integrable (fun x => x^2*w x) μ)
    (hf0 : Integrable (fun x => f x*w x) μ)
    (hf1 : Integrable (fun x => x*f x*w x) μ) :
    (∫ x,w x ∂μ)*(∫ x,x*f x*w x ∂μ)-(∫ x,f x*w x ∂μ)*(∫ x,x*w x ∂μ) ≤
      c*((∫ x,w x ∂μ)*(∫ x,x^2*w x ∂μ)-(∫ x,x*w x ∂μ)^2) := by
  have he : (fun x => (f x-c*x)*w x) = fun x => f x*w x-c*(x*w x) := by funext x; ring
  have he' : (fun x => x*(f x-c*x)*w x) = fun x => x*f x*w x-c*(x^2*w x) := by funext x; ring
  have hg0 : Integrable (fun x => (f x-c*x)*w x) μ := by rw [he]; exact hf0.sub (h1.const_mul c)
  have hg1 : Integrable (fun x => x*(f x-c*x)*w x) μ := by rw [he']; exact hf1.sub (h2.const_mul c)
  have hh := weighted_covariance_nonpos hw hf h0 h1 hg0 hg1
  rw [he,he',integral_sub hf1 (h2.const_mul c),integral_sub hf0 (h1.const_mul c),
    integral_const_mul,integral_const_mul] at hh
  nlinarith only [hh]

lemma weighted_variance_nonneg {μ : Measure ℝ} {f w : ℝ → ℝ}
    (hw : ∀ x, 0 ≤ w x) (h0 : Integrable w μ)
    (h1 : Integrable (fun x => f x*w x) μ) (h2 : Integrable (fun x => (f x)^2*w x) μ)
    (hZ : 0 < ∫ x,w x ∂μ) :
    (∫ x,f x*w x ∂μ)^2 ≤ (∫ x,w x ∂μ)*(∫ x,(f x)^2*w x ∂μ) := by
  let Z := ∫ x,w x ∂μ
  let U := ∫ x,f x*w x ∂μ
  let K := ∫ x,(f x)^2*w x ∂μ
  have hh : 0 ≤ ∫ x, Z^2*((f x)^2*w x)-(2*Z*U)*(f x*w x)+U^2*w x ∂μ := by
    apply integral_nonneg
    intro x
    change 0 ≤ Z^2*((f x)^2*w x)-(2*Z*U)*(f x*w x)+U^2*w x
    nlinarith [mul_nonneg (sq_nonneg (Z*f x-U)) (hw x)]
  rw [integral_three_linear h2 h1 h0 (Z^2) (2*Z*U) (U^2)] at hh
  change 0 ≤ Z^2*K-(2*Z*U)*U+U^2*Z at hh
  change 0 < Z at hZ
  change U^2 ≤ Z*K
  nlinarith [mul_pos hZ (by positivity : 0 < Z)]
end MicroscopicJamming

 
open MeasureTheory ProbabilityTheory Set Filter
open scoped NNReal ENNReal Topology

namespace MicroscopicJamming

lemma gaussian_weighted_poly_integrable {f w : ℝ → ℝ} (hf : Measurable f) (hw : Measurable w)
    {D M : ℝ} (hD : 0 ≤ D) (_hM : 0 ≤ M) (n : ℕ)
    (hb : ∀ z, |f z| ≤ D*(1+|z|)^n) (hwM : ∀ z, |w z| ≤ M) :
    Integrable (fun z => f z*w z) (gaussianReal 0 1) := by
  apply ((gaussian_abs_one_pow_integrable n).const_mul (D*M)).mono' (hf.mul hw).aestronglyMeasurable
  filter_upwards [] with z
  change |f z*w z| ≤ _
  rw [abs_mul]
  calc
    |f z| * |w z| ≤ (D*(1+|z|)^n)*M := mul_le_mul (hb z) (hwM z) (abs_nonneg _) (by positivity)
    _ = _ := by ring

structure GaussianRowMoments (u : ℝ → ℝ) (a x b : ℝ) : Prop where
  zero : Integrable (fun z => Real.exp (a*u (x+b*z))) (gaussianReal 0 1)
  first : Integrable (fun z => z*Real.exp (a*u (x+b*z))) (gaussianReal 0 1)
  second : Integrable (fun z => z^2*Real.exp (a*u (x+b*z))) (gaussianReal 0 1)
  slope : Integrable (fun z => deriv u (x+b*z)*Real.exp (a*u (x+b*z))) (gaussianReal 0 1)
  slope_first : Integrable (fun z => z*deriv u (x+b*z)*Real.exp (a*u (x+b*z))) (gaussianReal 0 1)
  slope_sq : Integrable (fun z => (deriv u (x+b*z))^2*Real.exp (a*u (x+b*z))) (gaussianReal 0 1)
  curvature : Integrable (fun z => deriv (deriv u) (x+b*z)*Real.exp (a*u (x+b*z))) (gaussianReal 0 1)

lemma gaussianRowMoments {u : ℝ → ℝ} {A B C κ Q a : ℝ}
    (hu : RowAnalyticTerminal u A B C κ Q) (ha : 0 ≤ a) (x b : ℝ) : GaussianRowMoments u a x b := by
  obtain ⟨L,hL,hlin⟩ := row_terminal_deriv_linear hu
  let K := L*(1+|x|+|b|)
  have hK : 0 ≤ K := by dsimp [K]; positivity
  have hbound (z : ℝ) : |deriv u (x+b*z)| ≤ K*(1+|z|) := by
    exact (hlin _).trans (by dsimp [K]; nlinarith [mul_le_mul_of_nonneg_left (heat_affine_bound x b z) hL])
  have hb (z : ℝ) : |deriv (deriv u) (x+b*z)| ≤ C+κ := by
    rw [abs_le]; have hh := hu.2.2.2.2.2.2 (x+b*z)
    constructor <;> linarith [hh.2.2.1,hh.2.2.2,hu.2.2.1,hu.2.2.2.1]
  have h0 := hu.1.continuous.measurable
  have h1 := (contDiff_infty_iff_deriv.mp hu.1).2.continuous.measurable
  have h2 := (contDiff_infty_iff_deriv.mp (contDiff_infty_iff_deriv.mp hu.1).2).2.continuous.measurable
  have hw : Measurable (fun z => Real.exp (a*u (x+b*z))) := by fun_prop
  have hwM (z : ℝ) : |Real.exp (a*u (x+b*z))| ≤ Real.exp (a*B) := by
    rw [abs_of_pos (Real.exp_pos _)]
    exact Real.exp_le_exp.mpr (mul_le_mul_of_nonneg_left (hu.2.2.2.2.2.2 _).2.1 ha)
  have hi {f : ℝ → ℝ} (hf : Measurable f) {D : ℝ} (hD : 0 ≤ D) (n : ℕ)
      (hd : ∀ z, |f z| ≤ D*(1+|z|)^n) :=
    gaussian_weighted_poly_integrable hf hw hD (Real.exp_pos (a*B)).le n hd hwM
  constructor
  · have hh := hi (f := fun _ => (1:ℝ)) measurable_const (D := 1) (by norm_num) 0 (fun z => by norm_num)
    simpa using hh
  · exact hi measurable_id (D := 1) (by norm_num) 1 (fun z => by simp)
  · refine hi (by fun_prop) (D := 1) (by norm_num) 2 (fun z => ?_)
    rw [abs_of_nonneg (sq_nonneg _)]
    nlinarith [abs_nonneg z,sq_abs z]
  · exact hi (by fun_prop) hK 1 (fun z => by simpa using hbound z)
  · refine hi (by fun_prop) hK 2 (fun z => ?_)
    rw [abs_mul]
    have hh := mul_le_mul_of_nonneg_left (hbound z) (abs_nonneg z)
    have hh' := mul_le_mul_of_nonneg_left (show |z| ≤ 1+|z| by linarith) (show 0 ≤ K*(1+|z|) by positivity)
    nlinarith
  · refine hi (by fun_prop) (sq_nonneg K) 2 (fun z => ?_)
    rw [abs_of_nonneg (sq_nonneg _)]
    have hh := pow_le_pow_left₀ (abs_nonneg (deriv u (x+b*z))) (hbound z) 2
    rw [sq_abs] at hh
    nlinarith only [hh]
  · exact hi (by fun_prop) (add_nonneg hu.2.2.1 hu.2.2.2.1) 0 (fun z => by simpa using hb z)
end MicroscopicJamming

 
open MeasureTheory ProbabilityTheory Set Filter
open scoped NNReal ENNReal Topology

namespace MicroscopicJamming

lemma row_gaussian_stein {u : ℝ → ℝ} {A B C κ Q a : ℝ}
    (hu : RowAnalyticTerminal u A B C κ Q) (ha : 0 ≤ a) (x b : ℝ) :
    let w := fun z => Real.exp (a*u (x+b*z))
    (∫ z,z*w z ∂gaussianReal 0 1) = a*b*(∫ z,deriv u (x+b*z)*w z ∂gaussianReal 0 1) ∧
    (∫ z,z*deriv u (x+b*z)*w z ∂gaussianReal 0 1) =
      b*(∫ z,deriv (deriv u) (x+b*z)*w z ∂gaussianReal 0 1)+
      a*b*(∫ z,(deriv u (x+b*z))^2*w z ∂gaussianReal 0 1) ∧
    (∫ z,z^2*w z ∂gaussianReal 0 1) = (∫ z,w z ∂gaussianReal 0 1)+
      a*b*(∫ z,z*deriv u (x+b*z)*w z ∂gaussianReal 0 1) := by
  dsimp only
  let w := fun z => Real.exp (a*u (x+b*z))
  have h := gaussianRowMoments hu ha x b
  obtain ⟨hdu,hcu'⟩ := contDiff_infty_iff_deriv.mp hu.1
  have hdu' := (contDiff_infty_iff_deriv.mp hcu').1
  have hy (z : ℝ) : HasDerivAt (fun r => x+b*r) b z := by
    convert (hasDerivAt_const z x).add ((hasDerivAt_id z).const_mul b) using 1 <;> first | rfl | simp
  have hw (z : ℝ) : HasDerivAt w (a*b*(deriv u (x+b*z)*w z)) z := by
    convert ((((hdu _).hasDerivAt.comp z (hy z)).const_mul a).exp) using 1 <;> first | rfl | (simp only [w,Function.comp_apply]; ring)
  have hs (z : ℝ) : HasDerivAt (fun r => deriv u (x+b*r)*w r)
      (b*(deriv (deriv u) (x+b*z)*w z)+a*b*((deriv u (x+b*z))^2*w z)) z := by
    convert (((hdu' _).hasDerivAt.comp z (hy z)).mul (hw z)) using 1 <;> first | rfl | (simp only [Function.comp_apply]; ring)
  have hz (z : ℝ) : HasDerivAt (fun r => r*w r)
      (w z+a*b*(z*deriv u (x+b*z)*w z)) z := by
    convert (hasDerivAt_id z).mul (hw z) using 1 <;> first | rfl | (simp only [id_eq]; ring)
  constructor
  · have hh := standardGaussian_integration_by_parts hw h.zero (h.slope.const_mul (a*b)) h.first
    rw [integral_const_mul] at hh
    exact hh
  constructor
  · have hi : Integrable (fun z => z*(deriv u (x+b*z)*w z)) (gaussianReal 0 1) := by
      simpa only [mul_assoc] using h.slope_first
    have hh := standardGaussian_integration_by_parts hs h.slope
      ((h.curvature.const_mul b).add (h.slope_sq.const_mul (a*b))) hi
    rw [integral_add (h.curvature.const_mul b) (h.slope_sq.const_mul (a*b)),
      integral_const_mul,integral_const_mul] at hh
    simpa only [mul_assoc] using hh
  · have hi : Integrable (fun z => z*(z*w z)) (gaussianReal 0 1) := by
      convert h.second using 1; funext z; dsimp [w]; ring
    have hh := standardGaussian_integration_by_parts hz h.first
      (h.zero.add (h.slope_first.const_mul (a*b))) hi
    rw [integral_add h.zero (h.slope_first.const_mul (a*b)),integral_const_mul] at hh
    convert hh using 1
    congr 1; funext z; ring
end MicroscopicJamming

 
open MeasureTheory ProbabilityTheory Set Filter
open scoped NNReal ENNReal Topology

namespace MicroscopicJamming

lemma gaussianRowOperator_second_exp {u : ℝ → ℝ} {A B C κ Q a : ℝ}
    (hu : RowAnalyticTerminal u A B C κ Q) (ha : 0 ≤ a) (haz : a ≠ 0) (T x : ℝ) :
    deriv (deriv (gaussianRowOperator a T u)) x =
      (1/a)*((gaussianHeat (rowExpSecond a u) T x * gaussianHeat (fun y => Real.exp (a*u y)) T x -
       (gaussianHeat (rowExpFirst a u) T x)^2)/(gaussianHeat (fun y => Real.exp (a*u y)) T x)^2) := by
  obtain ⟨hm,hm₁,hm₂⟩ := row_exp_measurable hu a
  obtain ⟨hg,hg₁,hg₂⟩ := row_exp_growth hu ha
  obtain ⟨hd,hd₁⟩ := row_exp_derivatives hu a
  have hp (y : ℝ) : gaussianHeat (fun z => Real.exp (a*u z)) T y ≠ 0 :=
    (integral_exp_pos (heat_affine_quadratic_integrable hm hg y (Real.sqrt T))).ne'
  have hx := gaussianHeat_space_derivative hm hm₁ hg hg₁ hd T
  have hxx := gaussianHeat_space_derivative hm₁ hm₂ hg₁ hg₂ hd₁ T
  have he : gaussianRowOperator a T u =
      fun y => (1/a)*Real.log (gaussianHeat (fun z => Real.exp (a*u z)) T y) := by
    funext y; simp only [gaussianRowOperator,ite_eq_right haz]
  have hdg (y : ℝ) : HasDerivAt (gaussianRowOperator a T u)
      ((1/a)*(gaussianHeat (rowExpFirst a u) T y/gaussianHeat (fun z => Real.exp (a*u z)) T y)) y := by
    rw [he]; exact ((hx y).log (hp y)).const_mul _
  have hdge : deriv (gaussianRowOperator a T u) =
      fun y => (1/a)*(gaussianHeat (rowExpFirst a u) T y/gaussianHeat (fun z => Real.exp (a*u z)) T y) :=
    funext fun y => (hdg y).deriv
  rw [hdge]
  have hh := (((hxx x).div (hx x) (hp x)).const_mul (1/a)).deriv
  convert hh using 1
  first | rfl | simp only [pow_two]

lemma gaussianRowOperator_second_moments {u : ℝ → ℝ} {A B C κ Q a : ℝ}
    (hu : RowAnalyticTerminal u A B C κ Q) (ha : 0 ≤ a) (haz : a ≠ 0) (T x : ℝ) :
    let w := fun z => Real.exp (a*u (x+Real.sqrt T*z))
    let Z := ∫ z,w z ∂gaussianReal 0 1
    let U := ∫ z,deriv u (x+Real.sqrt T*z)*w z ∂gaussianReal 0 1
    let V := ∫ z,(deriv u (x+Real.sqrt T*z))^2*w z ∂gaussianReal 0 1
    let J := ∫ z,deriv (deriv u) (x+Real.sqrt T*z)*w z ∂gaussianReal 0 1
    deriv (deriv (gaussianRowOperator a T u)) x = J/Z+a*(V/Z-(U/Z)^2) := by
  dsimp only
  have h := gaussianRowMoments hu ha x (Real.sqrt T)
  have hZ : (∫ z,Real.exp (a*u (x+Real.sqrt T*z)) ∂gaussianReal 0 1) ≠ 0 :=
    (integral_exp_pos h.zero).ne'
  have hfirst : gaussianHeat (rowExpFirst a u) T x =
      a*(∫ z,deriv u (x+Real.sqrt T*z)*Real.exp (a*u (x+Real.sqrt T*z)) ∂gaussianReal 0 1) := by
    rw [← integral_const_mul]
    unfold gaussianHeat rowExpFirst
    congr 1; funext z; ring
  have hsecond : gaussianHeat (rowExpSecond a u) T x =
      a*(∫ z,deriv (deriv u) (x+Real.sqrt T*z)*Real.exp (a*u (x+Real.sqrt T*z)) ∂gaussianReal 0 1)+
      a^2*(∫ z,(deriv u (x+Real.sqrt T*z))^2*Real.exp (a*u (x+Real.sqrt T*z)) ∂gaussianReal 0 1) := by
    rw [← integral_const_mul,← integral_const_mul,← integral_add (h.curvature.const_mul a) (h.slope_sq.const_mul (a^2))]
    unfold gaussianHeat rowExpSecond
    congr 1; funext z; ring
  rw [gaussianRowOperator_second_exp hu ha haz T x,hfirst,hsecond]
  unfold gaussianHeat
  field_simp [haz,hZ]
  ring
end MicroscopicJamming

 

namespace MicroscopicJamming
lemma row_curvature_algebra {a b C κ Z U V J L K S D : ℝ}
    (ha : 0 ≤ a) (ha1 : a ≤ 1) (hb : 0 < b) (hκ : 0 ≤ κ) (hκb : κ*b^2 < 1)
    (hZ : 0 < Z) (hJ : -C*Z ≤ J) (hvar : U^2 ≤ Z*V)
    (hL : L=a*b*U) (hK : K=b*J+a*b*V) (hS : S=Z+a*b*K)
    (hcov : Z*K-U*L ≤ (κ*b)*(Z*S-L^2))
    (hD : D=J/Z+a*(V/Z-(U/Z)^2)) :
    -C ≤ D ∧ D ≤ κ/(1-κ*b^2) := by
  have hZ2 : 0 < Z^2 := sq_pos_of_pos hZ
  have he : D*Z^2 = J*Z+a*(V*Z-U^2) := by
    rw [hD]; field_simp [hZ.ne']
  have hX : Z*K-U*L = b*(D*Z^2) := by
    rw [he,hL,hK]; ring
  have hY : Z*S-L^2 = Z^2+a*b^2*(D*Z^2) := by
    rw [he,hS,hK,hL]; ring
  rw [hX,hY] at hcov
  have hc : D*Z^2 ≤ κ*(Z^2+a*b^2*(D*Z^2)) := by
    apply (mul_le_mul_iff_right₀ hb).mp
    nlinarith only [hcov]
  have hden : 0 < 1-a*κ*b^2 := by
    have hh := mul_le_mul_of_nonneg_right ha1 (mul_nonneg hκ (sq_nonneg b))
    nlinarith
  have hden' : 0 < 1-κ*b^2 := by linarith
  constructor
  · have hp := mul_le_mul_of_nonneg_right hJ hZ.le
    have hv := mul_nonneg ha (sub_nonneg.mpr hvar)
    nlinarith
  · have hD' : D*(1-a*κ*b^2) ≤ κ := by
      apply (mul_le_mul_iff_left₀ hZ2).mp
      nlinarith only [hc]
    apply ((le_div_iff₀ hden).mpr hD').trans
    apply div_le_div_of_nonneg_left hκ hden' (by
      have hh := mul_le_mul_of_nonneg_right ha1 (mul_nonneg hκ (sq_nonneg b)); nlinarith)
end MicroscopicJamming

 
open MeasureTheory ProbabilityTheory Set Filter
open scoped NNReal ENNReal Topology

namespace MicroscopicJamming

lemma row_slope_antitone {u : ℝ → ℝ} {A B C κ Q : ℝ}
    (hu : RowAnalyticTerminal u A B C κ Q) (x : ℝ) {b : ℝ} (hb : 0 ≤ b) :
    Antitone (fun z => deriv u (x+b*z)-(κ*b)*z) := by
  obtain ⟨_,hcu⟩ := contDiff_infty_iff_deriv.mp hu.1
  have hd := (contDiff_infty_iff_deriv.mp hcu).1
  have hh (z : ℝ) : HasDerivAt (fun r => deriv u (x+b*r)-(κ*b)*r)
      (deriv (deriv u) (x+b*z)*b-κ*b) z := by
    have hy : HasDerivAt (fun r : ℝ => x+b*r) b z := by
      convert (hasDerivAt_const z x).add ((hasDerivAt_id z).const_mul b) using 1 <;> first | rfl | simp
    convert ((hd _).hasDerivAt.comp z hy).sub ((hasDerivAt_id z).const_mul (κ*b)) using 1 <;> first | rfl | simp
  apply antitone_of_deriv_nonpos (fun z => (hh z).differentiableAt)
  intro z
  rw [(hh z).deriv]
  exact sub_nonpos.mpr (mul_le_mul_of_nonneg_right (hu.2.2.2.2.2.2 _).2.2.2 hb)

lemma gaussianRowOperator_second_zero {u : ℝ → ℝ} {A B C κ Q : ℝ}
    (hu : RowAnalyticTerminal u A B C κ Q) (T x : ℝ) :
    deriv (deriv (gaussianRowOperator 0 T u)) x = gaussianHeat (deriv (deriv u)) T x := by
  obtain ⟨hd,hcu⟩ := contDiff_infty_iff_deriv.mp hu.1
  obtain ⟨hd',hcu'⟩ := contDiff_infty_iff_deriv.mp hcu
  have h1 := gaussianHeat_space_derivative hu.1.continuous.measurable hcu.continuous.measurable
    (row_terminal_quadratic_growth hu) (row_terminal_deriv_growth hu) (fun z => (hd z).hasDerivAt) T
  have h2 := gaussianHeat_space_derivative hcu.continuous.measurable hcu'.continuous.measurable
    (row_terminal_deriv_growth hu) (row_terminal_second_growth hu) (fun z => (hd' z).hasDerivAt) T
  have he : gaussianRowOperator 0 T u = gaussianHeat u T := by funext z; simp [gaussianRowOperator]
  rw [he,funext (fun z => (h1 z).deriv),(h2 x).deriv]

lemma gaussianRowOperator_curvature {u : ℝ → ℝ} {A B C κ Q a T : ℝ}
    (hu : RowAnalyticTerminal u A B C κ Q) (ha : 0 ≤ a) (ha1 : a ≤ 1)
    (hT : 0 < T) (hTQ : T ≤ Q) (x : ℝ) :
    -C ≤ deriv (deriv (gaussianRowOperator a T u)) x ∧
    deriv (deriv (gaussianRowOperator a T u)) x ≤ κ/(1-κ*T) := by
  have hk := hu.2.2.2.1
  have hkT : κ*T < 1 := (mul_le_mul_of_nonneg_left hTQ hk).trans_lt hu.2.2.2.2.1
  have hden : 0 < 1-κ*T := by linarith
  by_cases haz : a=0
  · subst a
    rw [gaussianRowOperator_second_zero hu T x]
    obtain ⟨_,hcu⟩ := contDiff_infty_iff_deriv.mp hu.1
    obtain ⟨_,hcu'⟩ := contDiff_infty_iff_deriv.mp hcu
    have hi := heat_affine_quadratic_integrable hcu'.continuous.measurable
      (row_terminal_second_growth hu) x (Real.sqrt T)
    have hl : -C ≤ gaussianHeat (deriv (deriv u)) T x := by
      calc
        -C = ∫ _ : ℝ,-C ∂gaussianReal 0 1 := by simp
        _ ≤ _ := integral_mono (integrable_const _) hi (fun z => (hu.2.2.2.2.2.2 _).2.2.1)
    have hr : gaussianHeat (deriv (deriv u)) T x ≤ κ := by
      calc
        _ ≤ ∫ _ : ℝ,κ ∂gaussianReal 0 1 :=
          integral_mono hi (integrable_const _) (fun z => (hu.2.2.2.2.2.2 _).2.2.2)
        _ = κ := by simp
    refine ⟨hl,hr.trans ?_⟩
    apply (le_div_iff₀ hden).mpr
    nlinarith [mul_nonneg hk hT.le]
  · let b := Real.sqrt T
    let w := fun z => Real.exp (a*u (x+b*z))
    have hb : 0 < b := Real.sqrt_pos.mpr hT
    have hb2 : b^2=T := Real.sq_sqrt hT.le
    have h := gaussianRowMoments hu ha x b
    have hZ : 0 < ∫ z,w z ∂gaussianReal 0 1 := integral_exp_pos h.zero
    have hJ : -C*(∫ z,w z ∂gaussianReal 0 1) ≤
        ∫ z,deriv (deriv u) (x+b*z)*w z ∂gaussianReal 0 1 := by
      rw [← integral_const_mul]
      exact integral_mono (h.zero.const_mul (-C)) h.curvature
        (fun z => mul_le_mul_of_nonneg_right (hu.2.2.2.2.2.2 _).2.2.1 (Real.exp_pos _).le)
    have hv := weighted_variance_nonneg (fun z => (Real.exp_pos (a*u (x+b*z))).le)
      h.zero h.slope h.slope_sq hZ
    have hc := weighted_covariance_upper (fun z => (Real.exp_pos (a*u (x+b*z))).le)
      (row_slope_antitone hu x hb.le) h.zero h.first h.second h.slope h.slope_first
    obtain ⟨hL,hK,hS⟩ := row_gaussian_stein hu ha x b
    have hD := gaussianRowOperator_second_moments hu ha haz T x
    have hh := row_curvature_algebra ha ha1 hb hk (by rwa [hb2]) hZ hJ hv hL hK hS hc hD
    simpa only [hb2] using hh

theorem gaussian_curvature : GaussianCurvatureStatement := by
  intro u A B C κ Q hQ hu a ha ha1 T hT hTQ x
  exact gaussianRowOperator_curvature hu ha ha1 hT hTQ x
end MicroscopicJamming

end

end OAI