lean/OAI/Probability/Perceptron/Variational/BcfEvalRingHom.lean

import Mathlib
import OAI.Probability.Perceptron.Variational.HeatTilt

namespace OAI

noncomputable section

open MeasureTheory ProbabilityTheory Filter Set
open scoped ENNReal NNReal Topology BigOperators BoundedContinuousFunction
open MeasureTheory ProbabilityTheory Set Filter
open scoped ENNReal NNReal BigOperators Topology RealInnerProductSpace
open scoped Pointwise
namespace SphericalPerceptronFreeEnergy
open Matrix
open scoped RealInnerProductSpace MatrixOrder
open TopologicalSpace
open scoped Polynomial
open scoped ContDiff

lemma shiftBCF_gaussian_integrable (f f' : ℝ →ᵇ ℝ)
    (hf : ∀ x, HasDerivAt (f:ℝ→ℝ) (f' x) x) (a : ℝ) :
    Integrable (fun z => shiftBCF f (a*z)) (gaussianReal 0 1) := by
  apply Integrable.of_bound ((shiftBCF_lipschitz f f' hf).continuous.comp
    (continuous_const.mul continuous_id)).aestronglyMeasurable ‖f‖
  exact ae_of_all _ (fun z => shiftBCF_norm_le f (a*z))

lemma gaussianAverage_scaling (s : ℝ≥0) (f : ℝ →ᵇ ℝ) (x : ℝ) :
    gaussianAverage s f x = ∫ z, f (x+Real.sqrt s*z) ∂gaussianReal 0 1 := by
  have hv : (⟨(Real.sqrt s)^2, sq_nonneg _⟩ : ℝ≥0) = s := by
    ext; exact Real.sq_sqrt s.coe_nonneg
  have hL := gaussianReal_const_mul (HasLaw.id (μ := gaussianReal 0 1)) (Real.sqrt s)
  simp only [mul_zero,NNReal.mk] at hL
  rw [hv,mul_one] at hL
  exact (hL.integral_comp (by fun_prop : AEStronglyMeasurable
    (fun z => f (x+z)) (gaussianReal 0 s))).symm

lemma gaussianAverageBCF_scaling (s : ℝ≥0) (g : Jet3) :
    gaussianAverageBCF s g.f = ∫ z, shiftBCF g.f (Real.sqrt s*z) ∂gaussianReal 0 1 := by
  have hi := shiftBCF_gaussian_integrable g.f g.d1 g.has1 (Real.sqrt s)
  ext x
  have he := (BoundedContinuousFunction.evalCLM ℝ x).integral_comp_comm hi
  change gaussianAverage s g.f x = _
  rw [gaussianAverage_scaling]
  exact he

lemma gaussianAverageBCF_time_hasDerivAt (g : Jet3) (s : ℝ) (hs : 0 < s) :
    HasDerivAt (fun t : ℝ => gaussianAverageBCF t.toNNReal g.f)
      ((1/2 : ℝ) • gaussianAverageBCF s.toNNReal g.d2) s := by
  let F : ℝ → ℝ → (ℝ →ᵇ ℝ) := fun t z => shiftBCF g.f (Real.sqrt t*z)
  let D : ℝ → ℝ → (ℝ →ᵇ ℝ) := fun t z =>
    (z / (2*Real.sqrt t)) • shiftBCF g.d1 (Real.sqrt t*z)
  have hz : Integrable (fun z : ℝ => |z|) (gaussianReal 0 1) := by
    simpa only [pow_one,id_eq] using gaussian_law_integrable_abs_pow
      (HasLaw.id (μ := gaussianReal 0 1)) 1
  have hm (t : ℝ) : AEStronglyMeasurable (F t) (gaussianReal 0 1) := by
    exact (shiftBCF_gaussian_integrable g.f g.d1 g.has1 (Real.sqrt t)).aestronglyMeasurable
  have hdm : AEStronglyMeasurable (D s) (gaussianReal 0 1) := by
    apply Continuous.aestronglyMeasurable
    exact (continuous_id.div_const _).smul ((shiftBCF_lipschitz g.d1 g.d2 g.has2).continuous.comp
      (continuous_const.mul continuous_id))
  have hb : ∀ᵐ z ∂gaussianReal 0 1, ∀ t ∈ Set.Ioo (s/2) (2*s),
      ‖D t z‖ ≤ |z| / (2*Real.sqrt (s/2)) * ‖g.d1‖ := by
    apply ae_of_all
    intro z t ht
    have ht0 : 0 < t := by linarith [ht.1]
    dsimp [D]
    rw [norm_smul,Real.norm_eq_abs,abs_div,abs_of_pos (by positivity : 0 < 2*Real.sqrt t)]
    apply mul_le_mul (div_le_div_of_nonneg_left (abs_nonneg z) (by positivity)
      (by gcongr; exact ht.1.le)) (shiftBCF_norm_le _ _) (norm_nonneg _) (by positivity)
  have hd : ∀ᵐ z ∂gaussianReal 0 1, ∀ t ∈ Set.Ioo (s/2) (2*s),
      HasDerivAt (fun t => F t z) (D t z) t := by
    apply ae_of_all
    intro z t ht
    have ht0 : t ≠ 0 := ne_of_gt (by linarith [ht.1])
    have hh := (shiftBCF_Jet3_hasDerivAt g (Real.sqrt t*z)).scomp t
      ((Real.hasDerivAt_sqrt ht0).mul_const z)
    simpa only [F,D,Function.comp_def,div_eq_mul_inv,_root_.mul_inv_rev,mul_comm,mul_left_comm,mul_assoc,one_mul] using hh
  have hh := hasDerivAt_integral_of_dominated_loc_of_deriv_le
    (Ioo_mem_nhds (by linarith : s/2 < s) (by linarith : s < 2*s))
    (Filter.Eventually.of_forall hm)
    (shiftBCF_gaussian_integrable g.f g.d1 g.has1 (Real.sqrt s))
    hdm hb ((hz.div_const _).mul_const ‖g.d1‖) hd
  have he : (∫ z, D s z ∂gaussianReal 0 1) =
      (1/2 : ℝ) • gaussianAverageBCF s.toNNReal g.d2 := by
    ext x
    have hev := (BoundedContinuousFunction.evalCLM ℝ x).integral_comp_comm hh.1
    have hib := standardGaussian_integrationByParts
      (F := fun z => g.d1 (x+Real.sqrt s*z))
      (F' := fun z => Real.sqrt s*g.d2 (x+Real.sqrt s*z))
      (C := ‖g.d1‖) (D := Real.sqrt s*‖g.d2‖)
      (fun z => by
        have h := (g.has2 (x+Real.sqrt s*z)).comp z
          (((hasDerivAt_id z).const_mul (Real.sqrt s)).const_add x)
        simpa only [Function.comp_def,id_eq,mul_one,one_mul,mul_comm] using h)
      (by fun_prop)
      (fun z => by simpa only [Real.norm_eq_abs] using g.d1.norm_coe_le_norm (x+Real.sqrt s*z))
      (fun z => by
        rw [abs_mul,abs_of_nonneg (Real.sqrt_nonneg _)]
        exact mul_le_mul_of_nonneg_left (g.d2.norm_coe_le_norm (x+Real.sqrt s*z))
          (Real.sqrt_nonneg _))
    change (∫ z, (D s z) x ∂gaussianReal 0 1) = (∫ z,D s z ∂gaussianReal 0 1) x at hev
    rw [← hev]
    change (∫ z, z/(2*Real.sqrt s)*g.d1 (x+Real.sqrt s*z) ∂gaussianReal 0 1) =
      (1/2)*gaussianAverage s.toNNReal g.d2 x
    rw [gaussianAverage_scaling,Real.coe_toNNReal s hs.le]
    have hc : (∫ z, z/(2*Real.sqrt s)*g.d1 (x+Real.sqrt s*z) ∂gaussianReal 0 1) =
        (2*Real.sqrt s)⁻¹ * ∫ z, z*g.d1 (x+Real.sqrt s*z) ∂gaussianReal 0 1 := by
      rw [← integral_const_mul]; congr 1; ext z; ring
    rw [hc,hib,integral_const_mul]
    field_simp [ne_of_gt (Real.sqrt_pos.mpr hs)]
  rw [he] at hh
  apply hh.2.congr_of_eventuallyEq
  filter_upwards [eventually_gt_nhds hs] with t ht
  exact (gaussianAverageBCF_scaling t.toNNReal g).trans (by rw [Real.coe_toNNReal t ht.le])

lemma log_lipschitz_above {a b c : ℝ} (hc : 0 < c) (ha : c ≤ a) (hb : c ≤ b) :
    |Real.log b-Real.log a| ≤ c⁻¹*|b-a| := by
  apply (convex_Ici c).norm_image_sub_le_of_norm_hasDerivWithin_le
    (fun x hx => (Real.hasDerivAt_log (ne_of_gt (hc.trans_le hx))).hasDerivWithinAt)
    (fun x hx => ?_) ha hb
  rw [Real.norm_eq_abs,abs_inv,abs_of_pos (hc.trans_le hx)]
  exact inv_anti₀ hc hx

lemma heatLogBCF_time_continuousAt (g : Jet3) (d : ℝ≥0) (s : ℝ) (hs : 0 < s) :
    ContinuousAt (fun t : ℝ => heatLogBCF t.toNNReal d g.f) s := by
  by_cases hd : d = 0
  · subst d
    have he : (fun t : ℝ => heatLogBCF t.toNNReal 0 g.f) =
        (fun t => gaussianAverageBCF t.toNNReal g.f) := by ext t x; simp [heatLog]
    rw [he]
    exact (gaussianAverageBCF_time_hasDerivAt g s hs).continuousAt
  let A : ℝ → (ℝ →ᵇ ℝ) := fun t => gaussianAverageBCF t.toNNReal (expBCF d g.f)
  let c : ℝ := Real.exp (-(d : ℝ)*‖g.f‖)
  have hc : 0 < c := Real.exp_pos _
  have hb t : ∀ x, c ≤ A t x := fun x => (gaussianAverage_exp_bounds t.toNNReal d d.coe_nonneg g.f x).1
  have ha : ContinuousAt A s := (gaussianAverageBCF_time_hasDerivAt (g.exp d) s hs).continuousAt
  have hbd t : ‖heatLogBCF t.toNNReal d g.f - heatLogBCF s.toNNReal d g.f‖ ≤
      (d : ℝ)⁻¹*c⁻¹*‖A t-A s‖ := by
    apply (BoundedContinuousFunction.norm_le (by positivity)).mpr
    intro x
    change |heatLog t.toNNReal d g.f x-heatLog s.toNNReal d g.f x| ≤ _
    simp only [heatLog,hd,↓reduceIte,← mul_sub,abs_mul,abs_inv,abs_of_nonneg d.coe_nonneg]
    calc
      _ ≤ (d : ℝ)⁻¹*(c⁻¹*|A t x-A s x|) :=
        mul_le_mul_of_nonneg_left (log_lipschitz_above hc (hb s x) (hb t x)) (by positivity)
      _ ≤ (d : ℝ)⁻¹*c⁻¹*‖A t-A s‖ := by
        rw [← mul_assoc]
        exact mul_le_mul_of_nonneg_left ((A t-A s).norm_coe_le_norm x) (by positivity)
  have ht : Tendsto (fun t => (d : ℝ)⁻¹*c⁻¹*‖A t-A s‖) (𝓝 s) (𝓝 0) := by
    simpa only [Pi.sub_apply,sub_self,norm_zero,mul_zero] using
      (ha.sub (continuousAt_const (y := A s))).norm.const_mul ((d : ℝ)⁻¹*c⁻¹) |>.tendsto
  exact tendsto_sub_nhds_zero_iff.mp (squeeze_zero_norm hbd ht)

private def bcfEvalRingHom (x : ℝ) : (ℝ →ᵇ ℝ) →+* ℝ where
  toFun := fun f => f x
  map_one' := rfl
  map_mul' _ _ := rfl
  map_zero' := rfl
  map_add' _ _ := rfl

lemma expBCF_eq_normedSpace_exp (d : ℝ) (f : ℝ →ᵇ ℝ) :
    expBCF d f = NormedSpace.exp (d • f) := by
  ext x
  have hh := NormedSpace.map_exp (bcfEvalRingHom x)
    (BoundedContinuousFunction.evalCLM ℝ x).continuous (d • f)
  change _ = (bcfEvalRingHom x) (NormedSpace.exp (d • f))
  rw [hh,← Real.exp_eq_exp_ℝ]
  rfl

lemma expBCF_hasFDerivAt (d : ℝ) (f : ℝ →ᵇ ℝ) :
    HasFDerivAt (expBCF d)
      ((expBCF d f • (1 : (ℝ →ᵇ ℝ) →L[ℝ] (ℝ →ᵇ ℝ))) ∘L
        (d • (1 : (ℝ →ᵇ ℝ) →L[ℝ] (ℝ →ᵇ ℝ)))) f := by
  have hh := (hasFDerivAt_exp (𝕂 := ℝ) (x := d • f)).comp f
    ((d • (1 : (ℝ →ᵇ ℝ) →L[ℝ] (ℝ →ᵇ ℝ))).hasFDerivAt)
  simpa only [← expBCF_eq_normedSpace_exp,one_apply_eq_self,
    _root_.smul_apply,Function.comp_def] using hh

def heatGenerator (d : ℝ≥0) (g : Jet3) : ℝ →ᵇ ℝ :=
  (1/2 : ℝ) • (g.d2 + (d : ℝ) • g.d1^2)

lemma heatLogBCF_time_hasDerivAt (g : Jet3) (d : ℝ≥0) (s : ℝ) (hs : 0 < s) :
    HasDerivAt (fun t : ℝ => heatLogBCF t.toNNReal d g.f)
      (heatGenerator d (g.heatLog s.toNNReal d)) s := by
  by_cases hd : d = 0
  · subst d
    convert gaussianAverageBCF_time_hasDerivAt g s hs using 1
    · ext t x; simp [heatLog]
    · simp [heatGenerator,Jet3.heatLog,Jet3.gaussianAverage]
  have hdR : (d : ℝ) ≠ 0 := NNReal.coe_ne_zero.mpr hd
  let U := heatLogBCF s.toNNReal d g.f
  let L : (ℝ →ᵇ ℝ) →L[ℝ] (ℝ →ᵇ ℝ) :=
    ((d : ℝ)⁻¹ • expBCF (-(d : ℝ)) U) • (1 : (ℝ →ᵇ ℝ) →L[ℝ] (ℝ →ᵇ ℝ))
  have hlin : Function.LeftInverse L
      ((expBCF d U • (1 : (ℝ →ᵇ ℝ) →L[ℝ] (ℝ →ᵇ ℝ))) ∘L
        ((d : ℝ) • (1 : (ℝ →ᵇ ℝ) →L[ℝ] (ℝ →ᵇ ℝ)))) := by
    intro h
    ext x
    change ((d : ℝ)⁻¹*Real.exp (-(d : ℝ)*U x))*(Real.exp ((d : ℝ)*U x)*((d : ℝ)*h x)) = h x
    calc
      _ = ((d : ℝ)⁻¹*d)*(Real.exp (-(d : ℝ)*U x)*Real.exp ((d : ℝ)*U x))*h x := by ring
      _ = h x := by rw [← Real.exp_add]; simp [hdR]
  have hcomp : expBCF d ∘ (fun t : ℝ => heatLogBCF t.toNNReal d g.f) =ᶠ[𝓝 s]
      (fun t : ℝ => gaussianAverageBCF t.toNNReal (g.exp d).f) := by
    apply Filter.Eventually.of_forall
    intro t
    ext x
    exact exp_heatLog t.toNNReal d hd g.f x
  have hh := HasFDerivAt.of_comp_of_leftInverse
    (heatLogBCF_time_continuousAt g d s hs) (expBCF_hasFDerivAt d U)
    (gaussianAverageBCF_time_hasDerivAt (g.exp d) s hs).hasFDerivAt hcomp hlin
  have he : L ((1/2 : ℝ) • gaussianAverageBCF s.toNNReal (g.exp d).d2) =
      heatGenerator d (g.heatLog s.toNNReal d) := by
    ext x
    have hex : Real.exp (-(d : ℝ)*U x) = (gaussianAverage s.toNNReal (expBCF d g.f) x)⁻¹ := by
      rw [neg_mul,Real.exp_neg,show Real.exp ((d : ℝ)*U x) = _ from exp_heatLog s.toNNReal d hd g.f x]
    change ((d : ℝ)⁻¹*Real.exp (-(d : ℝ)*U x)) *
      ((1/2)*gaussianAverage s.toNNReal (g.exp d).d2 x) = _
    rw [hex]
    simp only [Jet3.heatLog,hd,↓reduceDIte]
    change _ = (1/2)*((d : ℝ)⁻¹ *
      (gaussianAverage s.toNNReal (g.exp d).d2 x *
        (gaussianAverage s.toNNReal (expBCF d g.f) x)⁻¹ -
       (gaussianAverage s.toNNReal (g.exp d).d1 x)^2 *
        ((gaussianAverage s.toNNReal (expBCF d g.f) x)⁻¹)^2) +
      (d : ℝ)*((d : ℝ)⁻¹ * (gaussianAverage s.toNNReal (g.exp d).d1 x *
        (gaussianAverage s.toNNReal (expBCF d g.f) x)⁻¹))^2)
    field_simp [hdR,(gaussianAverage_exp_pos s.toNNReal d g.f x).ne']
    ring
  apply hh.hasDerivAt.congr_deriv
  simpa only [ContinuousLinearMap.comp_apply,ContinuousLinearMap.toSpanSingleton_apply,
    one_smul] using he

lemma gaussianAverageBCF_scaling_of_deriv (s : ℝ≥0) (f f' : ℝ →ᵇ ℝ)
    (hf : ∀ x, HasDerivAt (f:ℝ→ℝ) (f' x) x) :
    gaussianAverageBCF s f = ∫ z, shiftBCF f (Real.sqrt s*z) ∂gaussianReal 0 1 := by
  have hi := shiftBCF_gaussian_integrable f f' hf (Real.sqrt s)
  ext x
  have he := (BoundedContinuousFunction.evalCLM ℝ x).integral_comp_comm hi
  change gaussianAverage s f x = _
  rw [gaussianAverage_scaling]
  exact he

lemma gaussianAverageBCF_time_continuous_of_deriv (f f' : ℝ →ᵇ ℝ)
    (hf : ∀ x, HasDerivAt (f:ℝ→ℝ) (f' x) x) :
    Continuous (fun t : ℝ => gaussianAverageBCF t.toNNReal f) := by
  have he : (fun t : ℝ => gaussianAverageBCF t.toNNReal f) =
      (fun t : ℝ => ∫ z, shiftBCF f (Real.sqrt t.toNNReal*z) ∂gaussianReal 0 1) := by
    ext t x
    exact congrArg (fun h : ℝ →ᵇ ℝ => h x) (gaussianAverageBCF_scaling_of_deriv t.toNNReal f f' hf)
  rw [he]
  apply continuous_of_dominated (bound := fun _ => ‖f‖)
  · intro t
    exact (shiftBCF_gaussian_integrable f f' hf (Real.sqrt t.toNNReal)).aestronglyMeasurable
  · intro t
    exact ae_of_all _ (fun z => shiftBCF_norm_le f (Real.sqrt t.toNNReal*z))
  · exact integrable_const _
  · apply ae_of_all
    intro z
    apply (shiftBCF_lipschitz f f' hf).continuous.comp
    exact (Real.continuous_sqrt.comp (NNReal.continuous_coe.comp continuous_real_toNNReal)).mul_const z

lemma heatTiltBCF_time_continuous_of_deriv (f f' h h' : ℝ →ᵇ ℝ)
    (hf : ∀ x, HasDerivAt (f:ℝ→ℝ) (f' x) x)
    (hh : ∀ x, HasDerivAt (h:ℝ→ℝ) (h' x) x) (d : ℝ≥0) :
    Continuous (fun t : ℝ => heatTiltBCF t.toNNReal d f h) := by
  let A := expBCF d f
  let A' := (d : ℝ) • (A*f')
  have hA x : HasDerivAt (A:ℝ→ℝ) (A' x) x := by
    change HasDerivAt (fun y => Real.exp ((d : ℝ)*f y)) ((d : ℝ)*(A x*f' x)) x
    exact ((hf x).const_mul (d : ℝ)).exp.congr_deriv (by dsimp [A,expBCF]; ring)
  have hB x : HasDerivAt (A*h : ℝ →ᵇ ℝ) ((A'*h+A*h') x) x := by
    simpa only [BoundedContinuousFunction.coe_mul,Pi.mul_apply,
      BoundedContinuousFunction.coe_add,Pi.add_apply] using (hA x).mul (hh x)
  have hca := gaussianAverageBCF_time_continuous_of_deriv A A' hA
  have hcb := gaussianAverageBCF_time_continuous_of_deriv (A*h) (A'*h+A*h') hB
  let c := Real.exp (-(d : ℝ)*‖f‖)
  have hc : 0 < c := Real.exp_pos _
  let J (t : ℝ) := invBCF (gaussianAverageBCF t.toNNReal A) c hc
    (fun x => (gaussianAverage_exp_bounds t.toNNReal d d.coe_nonneg f x).1)
  have hJ : Continuous J := by
    apply continuous_iff_continuousAt.mpr
    intro s
    have hb t : ‖J t-J s‖ ≤ c⁻¹^2 * ‖gaussianAverageBCF t.toNNReal A-gaussianAverageBCF s.toNNReal A‖ := by
      apply (BoundedContinuousFunction.norm_le (by positivity)).mpr
      intro x
      change |(gaussianAverage t.toNNReal A x)⁻¹-(gaussianAverage s.toNNReal A x)⁻¹| ≤ _
      have h1 := (gaussianAverage_exp_bounds t.toNNReal d d.coe_nonneg f x).1
      have h2 := (gaussianAverage_exp_bounds s.toNNReal d d.coe_nonneg f x).1
      have h1p : 0 < gaussianAverage t.toNNReal A x := hc.trans_le h1
      have h2p : 0 < gaussianAverage s.toNNReal A x := hc.trans_le h2
      rw [inv_sub_inv h1p.ne' h2p.ne',abs_div,abs_mul,
        abs_of_pos h1p,abs_of_pos h2p,abs_sub_comm]
      calc
        _ ≤ ‖gaussianAverageBCF t.toNNReal A-gaussianAverageBCF s.toNNReal A‖/(c*c) :=
          div_le_div₀ (by positivity) ((gaussianAverageBCF t.toNNReal A-gaussianAverageBCF s.toNNReal A).norm_coe_le_norm x)
            (by positivity) (mul_le_mul h1 h2 hc.le h1p.le)
        _ = _ := by ring
    have ht : Tendsto (fun t => c⁻¹^2*‖gaussianAverageBCF t.toNNReal A-gaussianAverageBCF s.toNNReal A‖)
        (𝓝 s) (𝓝 0) := by
      simpa only [Pi.sub_apply,sub_self,norm_zero,mul_zero] using
        ((hca.continuousAt (x := s)).sub (continuousAt_const (y := gaussianAverageBCF s.toNNReal A))).norm.const_mul (c⁻¹^2) |>.tendsto
    exact tendsto_sub_nhds_zero_iff.mp (squeeze_zero_norm hb ht)
  have he : (fun t : ℝ => heatTiltBCF t.toNNReal d f h) =
      (fun t => gaussianAverageBCF t.toNNReal (A*h)*J t) := by
    ext t x
    change gaussianAverage t.toNNReal (A*h) x / gaussianAverage t.toNNReal A x = _
    rfl
  rw [he]
  exact hcb.mul hJ

lemma heatGenerator_hasDerivAt (g : Jet3) (d : ℝ≥0) (x : ℝ) :
    HasDerivAt (heatGenerator d g : ℝ → ℝ)
      (((1/2 : ℝ) • (g.d3+(2*(d:ℝ)) • (g.d1*g.d2))) x) x := by
  have hh := ((g.has3 x).add ((g.has2 x).pow 2 |>.const_mul (d : ℝ))).const_mul (1/2 : ℝ)
  change HasDerivAt (fun y => (1/2 : ℝ)*(g.d2 y+(d:ℝ)*(g.d1 y)^2))
    ((1/2 : ℝ)*(g.d3 x+(2*(d:ℝ))*(g.d1 x*g.d2 x))) x
  exact hh.congr_deriv (by norm_num; ring)

lemma heatTilt_heatGenerator (g : Jet3) (s d : ℝ≥0) :
    heatTiltCLM s d g.f (heatGenerator d g) = heatGenerator d (g.heatLog s d) := by
  by_cases hd : d = 0
  · subst d
    ext x
    simp only [heatGenerator,NNReal.coe_zero,zero_smul,add_zero]
    change heatTilt s 0 g.f ((1/2 : ℝ) • g.d2) x = _
    rw [heatTilt_zero,gaussianAverage_smul]
    simp only [Jet3.heatLog,↓reduceDIte]
    rfl
  have hdR : (d : ℝ) ≠ 0 := NNReal.coe_ne_zero.mpr hd
  ext x
  have hf : (g.exp d).d2 = (d : ℝ) • (expBCF d g.f*(g.d2+(d : ℝ) • g.d1^2)) := by
    ext z
    simp only [Jet3.exp,BoundedContinuousFunction.coe_smul,BoundedContinuousFunction.coe_add,
      BoundedContinuousFunction.coe_mul,BoundedContinuousFunction.coe_pow,
      Pi.add_apply,Pi.mul_apply,Pi.pow_apply,smul_eq_mul]
    ring
  have hf1 : (g.exp d).d1 = (d : ℝ) • (expBCF d g.f*g.d1) := rfl
  change heatTilt s d g.f (heatGenerator d g) x = _
  simp only [heatGenerator,heatTilt_smul,heatTilt_add,Jet3.heatLog,hd,↓reduceDIte]
  change (1/2)*(heatTilt s d g.f g.d2 x + (d:ℝ)*heatTilt s d g.f (g.d1^2) x) =
    (1/2)*((d : ℝ)⁻¹ *
      (gaussianAverage s (g.exp d).d2 x * (gaussianAverage s (expBCF d g.f) x)⁻¹ -
       (gaussianAverage s (g.exp d).d1 x)^2 * ((gaussianAverage s (expBCF d g.f) x)⁻¹)^2) +
      (d : ℝ)*((d : ℝ)⁻¹ * (gaussianAverage s (g.exp d).d1 x *
        (gaussianAverage s (expBCF d g.f) x)⁻¹))^2)
  rw [hf,hf1,gaussianAverage_smul,gaussianAverage_smul]
  have hm : expBCF d g.f*(g.d2+(d : ℝ) • g.d1^2) =
      expBCF d g.f*g.d2+(d : ℝ) • (expBCF d g.f*g.d1^2) := by ext z; simp; ring
  rw [hm,gaussianAverage_add,gaussianAverage_smul]
  unfold heatTilt
  simp only [BoundedContinuousFunction.coe_mul]
  field_simp [hdR,(gaussianAverage_exp_pos s d g.f x).ne']
  ring

lemma heatLogBCF_moving_hasDerivAt (g : Jet3) (d : ℝ≥0)
    (σ : ℝ → ℝ) (G : ℝ → (ℝ →ᵇ ℝ)) (θ v : ℝ) (h h' : ℝ →ᵇ ℝ)
    (hσ : HasDerivAt σ v θ) (hs : 0 < σ θ)
    (hG : HasDerivAt G h θ) (hGθ : G θ = g.f)
    (hh : ∀ x, HasDerivAt (h:ℝ→ℝ) (h' x) x) :
    HasDerivAt (fun t => heatLogBCF (σ t).toNNReal d (G t))
      (v • heatGenerator d (g.heatLog (σ θ).toNNReal d) +
        heatTiltCLM (σ θ).toNNReal d g.f h) θ := by
  let L (t : ℝ) := heatTiltCLM (σ t).toNNReal d g.f
  let A (t : ℝ) := heatLogBCF (σ t).toNNReal d g.f
  let K (t : ℝ) := G t-g.f
  have hK0 : Tendsto K (𝓝 θ) (𝓝 0) := by
    simpa only [hGθ,sub_self] using hG.continuousAt.tendsto.sub_const g.f
  have hKo : (fun t => ‖K t‖) =o[𝓝 θ] (fun _ => (1 : ℝ)) :=
    (Asymptotics.isLittleO_one_iff ℝ).mpr (by simpa only [norm_zero] using hK0.norm)
  have hKb : (fun t => ‖K t‖) =O[𝓝 θ] (fun t => t-θ) := by
    simpa only [hGθ] using hG.isBigO_sub.norm_left
  have hR : (fun t => heatLogBCF (σ t).toNNReal d (G t)-A t-L t (K t))
      =o[𝓝 θ] (fun t => t-θ) := by
    have hb : (fun t => heatLogBCF (σ t).toNNReal d (G t)-A t-L t (K t))
        =O[𝓝 θ] (fun t => ‖K t‖*‖K t‖) := by
      apply Asymptotics.IsBigO.of_bound (2*(d:ℝ))
      apply Filter.Eventually.of_forall
      intro t
      have he := heatLogBCF_terminal_quadratic_error (σ t).toNNReal d g.f (K t)
      simpa only [K,A,L,add_sub_cancel,norm_mul,Real.norm_of_nonneg (norm_nonneg _),pow_two] using he
    exact hb.trans_isLittleO (by simpa only [one_mul] using hKo.mul_isBigO hKb)
  have hE : (fun t => L t (G t-g.f-(t-θ) • h)) =o[𝓝 θ] (fun t => t-θ) := by
    have hb : (fun t => L t (G t-g.f-(t-θ) • h)) =O[𝓝 θ]
        (fun t => G t-g.f-(t-θ) • h) := by
      apply Asymptotics.IsBigO.of_bound'
      exact Filter.Eventually.of_forall (fun t => heatTiltBCF_norm_le (σ t).toNNReal d g.f _)
    apply hb.trans_isLittleO
    simpa only [hGθ] using hG.isLittleO
  have hLc : Tendsto (fun t => L t h-L θ h) (𝓝 θ) (𝓝 0) := by
    have hc := (heatTiltBCF_time_continuous_of_deriv g.f g.d1 h h' g.has1 hh d).continuousAt.comp
      hσ.continuousAt
    have he := hc.tendsto.sub_const (L θ h)
    change Tendsto (fun t => L t h-L θ h) (𝓝 θ) (𝓝 (L θ h-L θ h)) at he
    simpa only [sub_self] using he
  have hLo : (fun t => (t-θ) • (L t h-L θ h)) =o[𝓝 θ] (fun t => t-θ) := by
    have he := (Asymptotics.isBigO_refl (fun t : ℝ => t-θ) (𝓝 θ)).smul_isLittleO
      ((Asymptotics.isLittleO_one_iff ℝ).mpr hLc)
    simpa only [smul_eq_mul,mul_one] using he
  have hA : HasDerivAt A (v • heatGenerator d (g.heatLog (σ θ).toNNReal d)) θ :=
    (heatLogBCF_time_hasDerivAt g d (σ θ) hs).scomp θ hσ
  apply HasDerivAt.of_isLittleO
  apply ((hA.isLittleO.add hR).add hE |>.add hLo).congr_left
  intro t
  simp only [hGθ,K,A,L,map_sub,map_smul,smul_add,smul_sub]
  abel

lemma heatTiltBCF_hasDerivAt (s d : ℝ≥0) (f f' h h' : ℝ →ᵇ ℝ)
    (hf : ∀ x, HasDerivAt (f:ℝ→ℝ) (f' x) x)
    (hh : ∀ x, HasDerivAt (h:ℝ→ℝ) (h' x) x) (x : ℝ) :
    HasDerivAt (heatTiltBCF s d f h : ℝ→ℝ)
      ((heatTiltBCF s d f h' + (d:ℝ) •
        (heatTiltBCF s d f (f'*h)-heatTiltBCF s d f f'*heatTiltBCF s d f h)) x) x := by
  let A := expBCF d f
  let A' := (d : ℝ) • (A*f')
  have hA y : HasDerivAt (A:ℝ→ℝ) (A' y) y := by
    change HasDerivAt (fun z => Real.exp ((d:ℝ)*f z)) ((d:ℝ)*(A y*f' y)) y
    exact ((hf y).const_mul (d:ℝ)).exp.congr_deriv (by dsimp [A,expBCF]; ring)
  have hB y : HasDerivAt (A*h : ℝ→ᵇ ℝ) ((A'*h+A*h') y) y := by
    simpa only [BoundedContinuousFunction.coe_mul,Pi.mul_apply,
      BoundedContinuousFunction.coe_add,Pi.add_apply] using (hA y).mul (hh y)
  have he := (gaussianAverage_hasDerivAt s (A*h) (A'*h+A*h') hB x).div
    (gaussianAverage_hasDerivAt s A A' hA x) (gaussianAverage_exp_pos s d f x).ne'
  change HasDerivAt (fun y => gaussianAverage s (A*h) y / gaussianAverage s A y) _ x
  apply he.congr_deriv
  have hmul : A'*h = (d:ℝ) • (A*(f'*h)) := by ext y; dsimp [A']; ring
  rw [gaussianAverage_add,hmul,gaussianAverage_smul]
  symm
  change (gaussianAverage s (A*h') x/gaussianAverage s A x) +
    (d:ℝ)*((gaussianAverage s (A*(f'*h)) x/gaussianAverage s A x)-
      (gaussianAverage s (A*f') x/gaussianAverage s A x)*
        (gaussianAverage s (A*h) x/gaussianAverage s A x)) = _
  dsimp only [A']
  rw [gaussianAverage_smul]
  simp only [BoundedContinuousFunction.coe_mul]
  field_simp [show gaussianAverage s A x ≠ 0 from (gaussianAverage_exp_pos s d f x).ne']
  ring

end SphericalPerceptronFreeEnergy

end

end OAI