import Mathlib
import OAI.Probability.SKRatio.Calculus.SpectralLower

namespace OAI

section
noncomputable section
open scoped BigOperators Topology Matrix
open MeasureTheory Filter ContinuousLinearMap
namespace SKRatio.FiniteLaw
variable {α : Type*} [Fintype α]
attribute [local instance] Classical.propDecidable

def entropy (q f : α → ℝ) : ℝ :=
  mean q (fun x => f x * Real.log (f x)) - mean q f * Real.log (mean q f)

def relativeEntropy (p q : α → ℝ) : ℝ := ∑ x, p x * Real.log (p x / q x)

lemma mul_log_div (p q : ℝ) (hq : q ≠ 0) :
    p * Real.log (p/q) = p * Real.log p - p * Real.log q := by
  by_cases hp : p = 0
  · simp [hp]
  · rw [Real.log_div hp hq, mul_sub]

lemma relativeEntropy_nonneg (p q : α → ℝ) (hp : ∀ x, 0 ≤ p x)
    (hq : ∀ x, 0 < q x) (hp1 : ∑ x, p x = 1) (hq1 : ∑ x, q x = 1) :
    0 ≤ relativeEntropy p q := by
  have h (x : α) : p x-q x ≤ p x*Real.log (p x/q x) := by
    have hl := mul_le_mul_of_nonneg_left
      (Real.self_sub_one_le_mul_log (div_nonneg (hp x) (hq x).le)) (hq x).le
    calc
      p x-q x = q x*(p x/q x-1) := by field_simp [ne_of_gt (hq x)]
      _ ≤ q x*(p x/q x*Real.log (p x/q x)) := hl
      _ = p x*Real.log (p x/q x) := by field_simp [ne_of_gt (hq x)]
  have hs := Finset.sum_le_sum (s := Finset.univ) (fun x _ => h x)
  simpa only [Finset.sum_sub_distrib,hp1,hq1,sub_self,relativeEntropy] using hs

lemma entropy_density (p q : α → ℝ) (hq : ∀ x, q x ≠ 0)
    (hp1 : ∑ x, p x = 1) :
    entropy q (fun x => p x/q x) = relativeEntropy p q := by
  have hm : mean q (fun x => p x/q x) = 1 := by
    simpa only [mean,mul_div_cancel₀ _ (hq _)] using hp1
  rw [entropy,hm,Real.log_one,mul_zero,sub_zero]
  unfold mean relativeEntropy
  exact Finset.sum_congr rfl (fun x _ => by field_simp [hq x])

lemma relativeEntropy_continuous (q : α → ℝ) (hq : ∀ x, q x ≠ 0) :
    Continuous (fun p : α → ℝ => relativeEntropy p q) := by
  simp only [relativeEntropy,mul_log_div _ _ (hq _)]
  exact continuous_finsetSum _ (fun x _ =>
    (Real.continuous_mul_log.comp (continuous_apply x)).sub ((continuous_apply x).mul continuous_const))

lemma entropy_variational (p q a : α → ℝ) (hp : ∀ x, 0 ≤ p x)
    (hq : ∀ x, 0 < q x) (hp1 : ∑ x, p x = 1) (hq1 : ∑ x, q x = 1) :
    mean p a ≤ relativeEntropy p q + Real.log (mean q (fun x => Real.exp (a x))) := by
  have : Nonempty α := by
    by_contra h
    have : IsEmpty α := not_nonempty_iff.mp h
    simp at hq1
  let Z := mean q (fun x => Real.exp (a x))
  have hZ : 0 < Z := Finset.sum_pos (fun x _ => mul_pos (hq x) (Real.exp_pos _)) Finset.univ_nonempty
  let r (x : α) := q x*Real.exp (a x)/Z
  have hr (x : α) : 0 < r x := div_pos (mul_pos (hq x) (Real.exp_pos _)) hZ
  have hr1 : ∑ x, r x = 1 := by
    rw [show (∑ x, r x) = Z/Z by simp only [r,Z,mean,Finset.sum_div]]
    exact div_self (ne_of_gt hZ)
  have h := relativeEntropy_nonneg p r hp hr hp1 hr1
  have he (x : α) : p x*Real.log (p x/r x) =
      p x*Real.log (p x/q x) - p x*a x + p x*Real.log Z := by
    rw [mul_log_div _ _ (ne_of_gt (hr x)),mul_log_div _ _ (ne_of_gt (hq x))]
    rw [show Real.log (r x) = Real.log (q x) + a x - Real.log Z by
      dsimp only [r]
      rw [Real.log_div (ne_of_gt (mul_pos (hq x) (Real.exp_pos _))) (ne_of_gt hZ),
        Real.log_mul (ne_of_gt (hq x)) (Real.exp_ne_zero _),Real.log_exp]]
    ring
  simp only [relativeEntropy,he,Finset.sum_add_distrib,Finset.sum_sub_distrib,
    ← Finset.sum_mul,hp1,one_mul] at h
  dsimp only [mean,relativeEntropy,Z] at *
  linarith only [h]

lemma event_entropy_bound (p q : α → ℝ) (B : Set α) (hp : ∀ x, 0 ≤ p x)
    (hq : ∀ x, 0 < q x) (hp1 : ∑ x, p x = 1) (hq1 : ∑ x, q x = 1)
    {a : ℝ} (hsmall : mean q (fun x => if x ∈ B then 1 else 0) ≤ Real.exp (-a)) :
    a*mean p (fun x => if x ∈ B then 1 else 0) ≤ relativeEntropy p q+Real.log 2 := by
  classical
  have h := entropy_variational p q (fun x => if x ∈ B then a else 0) hp hq hp1 hq1
  have hm : mean q (fun x => Real.exp (if x ∈ B then a else 0)) ≤ 2 := by
    calc
      _ ≤ ∑ x, (q x + Real.exp a*(q x*(if x ∈ B then 1 else 0))) := by
        apply Finset.sum_le_sum
        intro x _
        by_cases hx : x ∈ B <;> simp only [hx,↓reduceIte,Real.exp_zero,mul_one,mul_zero]
        · nlinarith only [hq x]
        · simp
      _ = 1+Real.exp a*mean q (fun x => if x ∈ B then 1 else 0) := by
        simp only [Finset.sum_add_distrib,← Finset.mul_sum,hq1,mean]
      _ ≤ 1+Real.exp a*Real.exp (-a) :=
        add_le_add le_rfl (mul_le_mul_of_nonneg_left hsmall (Real.exp_nonneg _))
      _ = 2 := by rw [← Real.exp_add,add_neg_cancel,Real.exp_zero]; norm_num
  have hmpos : 0 < mean q (fun x => Real.exp (if x ∈ B then a else 0)) := by
    have : Nonempty α := by
      by_contra h
      have : IsEmpty α := not_nonempty_iff.mp h
      simp at hp1
    exact Finset.sum_pos (fun x _ => mul_pos (hq x) (Real.exp_pos _)) Finset.univ_nonempty
  have hlog := Real.log_le_log hmpos hm
  have he : mean p (fun x => if x ∈ B then a else 0) =
      a*mean p (fun x => if x ∈ B then 1 else 0) := by
    simp only [mean,Finset.mul_sum]
    apply Finset.sum_congr rfl
    intro x _
    split_ifs <;> ring
  rw [he] at h
  linarith only [h,hlog]

lemma hellinger_pointwise {p q : ℝ} (hp : 0 ≤ p) (hq : 0 < q) :
    2*p-2*Real.sqrt p*Real.sqrt q ≤ p*Real.log (p/q) := by
  rcases eq_or_lt_of_le hp with hp0 | hp0
  · simp [← hp0]
  have hp' := Real.sqrt_pos.mpr hp0
  have hq' := Real.sqrt_pos.mpr hq
  have hlog := Real.log_le_sub_one_of_pos (div_pos hq' hp')
  have h := mul_le_mul_of_nonneg_left hlog (by positivity : 0 ≤ 2*p)
  have he : Real.log (Real.sqrt q/Real.sqrt p) = -(Real.log (p/q))/2 := by
    rw [Real.log_div (ne_of_gt hq') (ne_of_gt hp'),Real.log_sqrt hq.le,Real.log_sqrt hp,
      Real.log_div (ne_of_gt hp0) (ne_of_gt hq)]
    ring
  rw [he] at h
  have hr : p*(Real.sqrt q/Real.sqrt p) = Real.sqrt p*Real.sqrt q := by
    nth_rw 1 [← Real.sq_sqrt hp]
    field_simp
  nlinarith only [h,hr]

lemma hellinger_le_entropy (p q : α → ℝ) (hp : ∀ x, 0 ≤ p x)
    (hq : ∀ x, 0 < q x) (hp1 : ∑ x, p x = 1) (hq1 : ∑ x, q x = 1) :
    (∑ x, (Real.sqrt (p x)-Real.sqrt (q x))^2) ≤ relativeEntropy p q := by
  have h := Finset.sum_le_sum (s := Finset.univ)
    (fun x _ => hellinger_pointwise (hp x) (hq x))
  have he (x : α) : (Real.sqrt (p x)-Real.sqrt (q x))^2 =
      p x+q x-2*Real.sqrt (p x)*Real.sqrt (q x) := by
    nlinarith only [Real.sq_sqrt (hp x),Real.sq_sqrt (hq x).le]
  simp only [he,Finset.sum_sub_distrib,Finset.sum_add_distrib,hp1,hq1]
  simpa only [Finset.sum_sub_distrib,← Finset.mul_sum,hp1,relativeEntropy,
    mul_one,show (1:ℝ)+1=2 by norm_num] using h

lemma totalVariation_square_le_entropy (p q : α → ℝ) (hp : ∀ x, 0 ≤ p x)
    (hq : ∀ x, 0 < q x) (hp1 : ∑ x, p x = 1) (hq1 : ∑ x, q x = 1) :
    totalVariation p q ^ 2 ≤ relativeEntropy p q := by
  have hcs := Finset.sum_mul_sq_le_sq_mul_sq Finset.univ
    (fun x => |Real.sqrt (p x)-Real.sqrt (q x)|)
    (fun x => Real.sqrt (p x)+Real.sqrt (q x))
  have he (x : α) : |Real.sqrt (p x)-Real.sqrt (q x)| *
      (Real.sqrt (p x)+Real.sqrt (q x)) = |p x-q x| := by
    rw [← abs_of_nonneg (add_nonneg (Real.sqrt_nonneg _) (Real.sqrt_nonneg _)),← abs_mul]
    congr 1
    nlinarith only [Real.sq_sqrt (hp x),Real.sq_sqrt (hq x).le]
  have hrest : ∑ x, (Real.sqrt (p x)+Real.sqrt (q x))^2 ≤ 4 := by
    calc
      _ ≤ ∑ x, (2*p x+2*q x) := by
        apply Finset.sum_le_sum
        intro x _
        nlinarith only [sq_nonneg (Real.sqrt (p x)-Real.sqrt (q x)),
          Real.sq_sqrt (hp x),Real.sq_sqrt (hq x).le]
      _ = 4 := by simp only [Finset.sum_add_distrib,← Finset.mul_sum,hp1,hq1]; norm_num
  simp only [he,sq_abs] at hcs
  have hb := mul_le_mul_of_nonneg_left hrest (Finset.sum_nonneg (s := Finset.univ) (fun x _ => sq_nonneg
    (Real.sqrt (p x)-Real.sqrt (q x))))
  have hh := hellinger_le_entropy p q hp hq hp1 hq1
  unfold totalVariation
  nlinarith only [hcs,hb,hh]

end SKRatio.FiniteLaw

namespace SKRatio.Calculus
attribute [local instance] Classical.propDecidable

lemma continuousKernel_balance {n : ℕ} (g : Disorder n) (t : ℝ) (x y : Spin n) :
    mass g 0 x*continuousKernel (coupling g) t x y =
      mass g 0 y*continuousKernel (coupling g) t y x := by
  have hs := semigroup_symmetric g t (fun z => if z = x then 1 else 0)
    (fun z => if z = y then 1 else 0)
  simpa only [stationaryInner,FiniteLaw.mean,ite_mul,one_mul,zero_mul,mul_ite,
    mul_one,mul_zero,Finset.sum_ite_eq',Finset.mem_univ,↓reduceIte,continuousKernel]
      using hs

def transitionDensity {n : ℕ} (g : Disorder n) (t : ℝ) (x : Spin n) : Observables n :=
  fun y => continuousKernel (coupling g) t x y/mass g 0 y

lemma transitionDensity_eq_semigroup {n : ℕ} (g : Disorder n) (t : ℝ) (x : Spin n) :
    transitionDensity g t x = semigroup (coupling g) t
      (fun y => if y = x then (mass g 0 x)⁻¹ else 0) := by
  funext y
  rw [semigroup_eq_kernel]
  simp only [FiniteLaw.mean,mul_ite,mul_zero,Finset.sum_ite_eq',Finset.mem_univ,↓reduceIte]
  dsimp only [transitionDensity]
  field_simp [ne_of_gt (mass_pos g 0 x),ne_of_gt (mass_pos g 0 y)]
  nlinarith only [continuousKernel_balance g t x y]

lemma transitionDensity_pos {n : ℕ} (g : Disorder n) {t : ℝ} (ht : 0 < t) (x y : Spin n) :
    0 < transitionDensity g t x y := div_pos (continuousKernel_pos g ht x y) (mass_pos g 0 y)

lemma transitionDensity_mean {n : ℕ} (g : Disorder n) (t : ℝ) (x : Spin n) :
    FiniteLaw.mean (mass g 0) (transitionDensity g t x) = 1 := by
  simp only [FiniteLaw.mean,transitionDensity,mul_div_cancel₀ _ (ne_of_gt (mass_pos g 0 _)),
    continuousKernel_sum]

lemma transitionDensity_hasDerivAt {n : ℕ} (g : Disorder n) (x : Spin n) (t : ℝ) :
    HasDerivAt (fun t => transitionDensity g t x)
      (generator (coupling g) (transitionDensity g t x)) t := by
  simp_rw [transitionDensity_eq_semigroup]
  exact semigroup_apply_hasDerivAt' _ _ _

def transitionEntropy {n : ℕ} (g : Disorder n) (x : Spin n) (t : ℝ) : ℝ :=
  FiniteLaw.relativeEntropy (continuousKernel (coupling g) t x) (mass g 0)

lemma transitionEntropy_eq {n : ℕ} (g : Disorder n) (x : Spin n) (t : ℝ) :
    transitionEntropy g x t =
      FiniteLaw.mean (mass g 0) (fun y => transitionDensity g t x y *
        Real.log (transitionDensity g t x y)) := by
  rw [transitionEntropy,← FiniteLaw.entropy_density _ _ (fun y => ne_of_gt (mass_pos g 0 y))
    (continuousKernel_sum _ t x)]
  change FiniteLaw.entropy (mass g 0) (transitionDensity g t x) = _
  simp only [FiniteLaw.entropy,transitionDensity_mean,Real.log_one,mul_zero,sub_zero]

lemma transitionEntropy_continuous {n : ℕ} (g : Disorder n) (x : Spin n) :
    Continuous (transitionEntropy g x) := by
  exact (FiniteLaw.relativeEntropy_continuous (mass g 0) (fun y => ne_of_gt (mass_pos g 0 y))).comp
    (continuous_pi (continuousKernel_continuous_time (coupling g) x))

lemma transitionEntropy_zero {n : ℕ} (g : Disorder n) (x : Spin n) :
    transitionEntropy g x 0 = Real.log (1/mass g 0 x) := by
  simp [transitionEntropy,FiniteLaw.relativeEntropy,Matrix.one_apply,ite_mul,ite_div]

lemma transitionEntropy_hasDerivAt {n : ℕ} (g : Disorder n) (x : Spin n)
    {t : ℝ} (ht : 0 < t) :
    HasDerivAt (transitionEntropy g x)
      (stationaryInner g (generator (coupling g) (transitionDensity g t x))
        (fun y => Real.log (transitionDensity g t x y))) t := by
  have hd (y : Spin n) := hasDerivAt_pi.mp (transitionDensity_hasDerivAt g x t) y
  have hp (y : Spin n) := (Real.hasDerivAt_mul_log
      (ne_of_gt (transitionDensity_pos g ht x y))).comp t (hd y)
  have hm := (gibbsMeanCLM g).hasFDerivAt.comp_hasDerivAt t (hasDerivAt_pi.mpr hp)
  have he : (fun t => gibbsMeanCLM g (fun y => transitionDensity g t x y*
      Real.log (transitionDensity g t x y))) = transitionEntropy g x := by
    funext t
    rw [gibbsMeanCLM_apply,transitionEntropy_eq]
  change HasDerivAt (fun r => gibbsMeanCLM g
    (fun y => transitionDensity g r x y*Real.log (transitionDensity g r x y))) _ t at hm
  rw [he] at hm
  apply hm.congr_deriv
  have hz := gibbsMean_generator g (transitionDensity g t x)
  simp only [gibbsMeanCLM_apply,FiniteLaw.mean] at hz ⊢
  simp only [stationaryInner,FiniteLaw.mean,add_mul,one_mul,mul_add,Finset.sum_add_distrib,hz,
    add_zero]
  exact Finset.sum_congr rfl (fun y _ => by ring)

theorem transitionEntropy_decay {n : ℕ} (g : Disorder n) {χ : ℝ}
    (hmlsi : ∀ F : Observables n, (∀ y, 0 < F y) → FiniteLaw.mean (mass g 0) F = 1 →
      χ*FiniteLaw.entropy (mass g 0) F ≤
        -stationaryInner g (generator (coupling g) F) (fun y => Real.log (F y)))
    (x : Spin n) {t : ℝ} (ht : 0 ≤ t) :
    transitionEntropy g x t ≤ Real.exp (-χ*t)*Real.log (1/mass g 0 x) := by
  let H (r : ℝ) := Real.exp (χ*r)*transitionEntropy g x r
  have hd (r : ℝ) (hr : 0 < r) : HasDerivAt H
      (Real.exp (χ*r)*(χ*transitionEntropy g x r+
        stationaryInner g (generator (coupling g) (transitionDensity g r x))
          (fun y => Real.log (transitionDensity g r x y)))) r := by
    have h := (((hasDerivAt_id r).const_mul χ).exp).mul (transitionEntropy_hasDerivAt g x hr)
    convert! h using 1
    first | rfl | (simp only [id_eq]; ring)
  have hc : Continuous H := (Real.continuous_exp.comp (continuous_const.mul continuous_id)).mul
    (transitionEntropy_continuous g x)
  have hanti : AntitoneOn H (Set.Ici 0) := by
    apply antitoneOn_of_deriv_nonpos (convex_Ici _) hc.continuousOn
    · intro r hr
      rw [interior_Ici,Set.mem_Ioi] at hr
      exact (hd r hr).differentiableAt.differentiableWithinAt
    · intro r hr
      rw [interior_Ici,Set.mem_Ioi] at hr
      rw [(hd r hr).deriv]
      apply mul_nonpos_of_nonneg_of_nonpos (Real.exp_nonneg _)
      have h := hmlsi (transitionDensity g r x) (transitionDensity_pos g hr x)
        (transitionDensity_mean g r x)
      rw [FiniteLaw.entropy,transitionDensity_mean,Real.log_one,mul_zero,sub_zero,
        ← transitionEntropy_eq] at h
      linarith only [h]
  have h := hanti (by simp) ht ht
  have hzero : H 0 = Real.log (1/mass g 0 x) := by simp [H,transitionEntropy_zero]
  rw [hzero] at h
  have hm := mul_le_mul_of_nonneg_left h (Real.exp_nonneg (-χ*t))
  calc
    _ = Real.exp (-χ*t)*H t := by
      dsimp only [H]
      rw [← mul_assoc,← Real.exp_add,show -χ*t+χ*t=0 by ring,Real.exp_zero,one_mul]
    _ ≤ _ := hm

lemma abs_hamiltonian_le_norm {n : ℕ} (g : Disorder n) (x : Spin n) :
    |hamiltonian g 0 x| ≤ euclideanOpNorm (coupling g)*(n:ℝ)/2 := by
  let X : EuclideanSpace ℝ (Fin n) := WithLp.toLp 2 (fun i => spinValue (x i))
  have hid : hamiltonian g 0 x = (1/2:ℝ)*inner ℝ X
      (Matrix.toEuclideanCLM (𝕜 := ℝ) (n := Fin n) (coupling g) X) := by
    rw [Matrix.inner_toEuclideanCLM (coupling g : Matrix (Fin n) (Fin n) ℝ) X X]
    simp only [hamiltonian,Pi.zero_apply,zero_mul,Finset.sum_const_zero,add_zero,dotProduct,
      Matrix.mulVec,Finset.mul_sum,X,mul_assoc]
  have hX : ‖X‖^2 = (n:ℝ) := by
    simp [X,EuclideanSpace.real_norm_sq_eq,Independent.spinValue_sq]
  rw [hid,abs_mul,abs_of_nonneg (by norm_num : (0:ℝ)≤1/2)]
  calc
    _ ≤ (1/2:ℝ)*(‖X‖*‖Matrix.toEuclideanCLM (𝕜 := ℝ) (n := Fin n) (coupling g) X‖) :=
      mul_le_mul_of_nonneg_left (abs_real_inner_le_norm _ _) (by norm_num)
    _ ≤ (1/2:ℝ)*(‖X‖*(euclideanOpNorm (coupling g)*‖X‖)) :=
      mul_le_mul_of_nonneg_left (mul_le_mul_of_nonneg_left
        ((Matrix.toEuclideanCLM (𝕜 := ℝ) (n := Fin n) (coupling g)).le_opNorm X)
          (norm_nonneg X)) (by norm_num)
    _ = _ := by rw [← hX]; ring

lemma log_inverse_mass_le {n : ℕ} (g : Disorder n) (x : Spin n) :
    Real.log (1/mass g 0 x) ≤ (n:ℝ)*(Real.log 2+euclideanOpNorm (coupling g)) := by
  let b := euclideanOpNorm (coupling g)*(n:ℝ)/2
  have he (y : Spin n) : |hamiltonian g 0 y| ≤ b := abs_hamiltonian_le_norm g y
  have hp : partition g 0 ≤ (2:ℝ)^n*Real.exp b := by
    calc
      _ ≤ ∑ y : Spin n, Real.exp b := Finset.sum_le_sum
        (fun y _ => Real.exp_le_exp.mpr ((le_abs_self _).trans (he y)))
      _ = _ := by simp [Spin]
  have hlog := Real.log_le_log (partition_pos g 0) hp
  rw [Real.log_mul (by positivity : (2:ℝ)^n ≠ 0) (Real.exp_ne_zero _),
    Real.log_pow,Real.log_exp] at hlog
  have hinv : Real.log (1/mass g 0 x) = Real.log (partition g 0)-hamiltonian g 0 x := by
    rw [mass,weight,one_div_div,Real.log_div (ne_of_gt (partition_pos g 0)) (Real.exp_ne_zero _),
      Real.log_exp]
  rw [hinv]
  have hl := (abs_le.mp (he x)).1
  dsimp only [b] at hlog hl
  linarith only [hlog,hl]

lemma continuousDistance_square_le_entropy {n : ℕ} (g : Disorder n) {t H : ℝ}
    (ht : 0 ≤ t) (hH : ∀ x, transitionEntropy g x t ≤ H) :
    continuousDistance g t ^ 2 ≤ H := by
  obtain ⟨x, -, hx⟩ := Finset.exists_mem_eq_sup' Finset.univ_nonempty
    (fun x : Spin n => totalVariation (continuousKernel (coupling g) t x) (mass g 0))
  change (Finset.univ.sup' _ _)^2 ≤ _
  rw [hx]
  exact (FiniteLaw.totalVariation_square_le_entropy _ _ (continuousKernel_nonneg _ t ht x)
    (mass_pos g 0) (continuousKernel_sum _ t x) (sum_mass g 0)).trans (hH x)

lemma continuousDistance_square_decay {n : ℕ} (g : Disorder n) {χ : ℝ}
    (hmlsi : ∀ F : Observables n, (∀ y, 0 < F y) → FiniteLaw.mean (mass g 0) F = 1 →
      χ*FiniteLaw.entropy (mass g 0) F ≤
        -stationaryInner g (generator (coupling g) F) (fun y => Real.log (F y)))
    {t : ℝ} (ht : 0 ≤ t) :
    continuousDistance g t ^ 2 ≤
      Real.exp (-χ*t)*(n:ℝ)*(Real.log 2+euclideanOpNorm (coupling g)) := by
  apply continuousDistance_square_le_entropy g ht
  intro x
  exact (transitionEntropy_decay g hmlsi x ht).trans
    (by
      simpa only [mul_assoc] using mul_le_mul_of_nonneg_left
        (log_inverse_mass_le g x) (Real.exp_nonneg (-χ*t)))

theorem uniform_median_upper_of_mlsi
    (G : ∀ n : ℕ, Set (Disorder n)) {χ K : ℝ} (hχ : 0 < χ)
    (hnorm : ∀ n, ∀ g ∈ G n, euclideanOpNorm (coupling g) ≤ K)
    (hmlsi : ∀ n, ∀ g ∈ G n, ∀ F : Observables n,
      (∀ y, 0 < F y) → FiniteLaw.mean (mass g 0) F = 1 →
      χ*FiniteLaw.entropy (mass g 0) F ≤
        -stationaryInner g (generator (coupling g) F) (fun y => Real.log (F y))) :
    ∀ᶠ n : ℕ in atTop, ∀ g ∈ G n, medianTime g ≤ (2/χ)*Real.log n := by
  have hvan := (dimensionDecay_tendsto_zero (by norm_num : (0:ℝ)<1)).mul_const (Real.log 2+K)
  simp only [zero_mul] at hvan
  filter_upwards [hvan.eventually (gt_mem_nhds (by norm_num : (0:ℝ)<1/4)),
    eventually_ge_atTop 1] with n hnsmall hn
  intro g hg
  have htime : 0 ≤ (2/χ)*Real.log n := mul_nonneg (by positivity)
    (Real.log_nonneg (by exact_mod_cast hn))
  apply (medianTime_le_iff g htime).mpr
  have h := continuousDistance_square_decay g (hmlsi n g hg) htime
  have hcoeff : Real.exp (-χ*((2/χ)*Real.log n))*(n:ℝ) = dimensionDecay 1 n := by
    have hed : -χ*((2/χ)*Real.log n) = -2*Real.log n := by field_simp
    rw [hed,mul_comm,← dimensionDecay,nat_mul_dimensionDecay (by omega)]
    norm_num
  rw [hcoeff] at h
  have hkn := mul_le_mul_of_nonneg_left (add_le_add_left (hnorm n g hg) (Real.log 2))
    (dimensionDecay_pos 1 n).le
  have hnD := continuousDistance_nonneg g ((2/χ)*Real.log n)
  nlinarith only [h,hkn,hnsmall,hnD]

end SKRatio.Calculus

end
end

end OAI