lean/OAI/Analysis/AllenCahn/DefectLimits.lean

import OAI.Analysis.AllenCahn.SmallDefect

namespace OAI

noncomputable section
namespace DeGiorgi
open Filter Set Topology
open scoped NNReal
open scoped ContDiff
open Filter Topology

lemma SmallDefectConverges.D_over_root_vanishes {n : ℕ} {v : ℕ → Space n → ℝ}
    {g : SmallDefectIndex n → Space n → ℝ} (hg : SmallDefectConverges v g)
    (hv : ∀ j, v j ∈ positiveDefectClass n)
    (he : Tendsto (fun j => diffuseDefect (v j) 0) atTop (𝓝 0))
    (l : List (Fin n)) (x : Space n) :
    Tendsto (fun j => (defectRoot (v j) 0)⁻¹*coordinateJet (diffuseDefect (v j)) l x)
      atTop (𝓝 0) := by
  have HH := (smallDefect_root_tendsto hv he).mul (hg.at_D l x)
  have heq (j : ℕ) : defectRoot (v j) 0*((diffuseDefect (v j) 0)⁻¹*
      coordinateJet (diffuseDefect (v j)) l x) =
      (defectRoot (v j) 0)⁻¹*coordinateJet (diffuseDefect (v j)) l x := by
    rw [← defectRoot_sq ((hv j).2.2.2 0)]
    field_simp [(defectRoot_pos (v j) 0).ne']
  simpa only [heq,zero_mul] using HH

lemma profile_contDiff : ContDiff ℝ ∞ profile := by
  have hT : ContDiff ℝ ∞ Real.tanh := by
    rw [funext Real.tanh_eq_sinh_div_cosh]
    exact Real.contDiff_sinh.div Real.contDiff_cosh (fun y => (Real.cosh_pos y).ne')
  exact hT.comp (contDiff_id.div_const _)

lemma SmallDefectConverges.v_limit {n : ℕ} {v : ℕ → Space n → ℝ}
    {g : SmallDefectIndex n → Space n → ℝ} (hg : SmallDefectConverges v g)
    (hv : ∀ j, v j ∈ positiveDefectClass n) (x : Space n) :
    Tendsto (fun j => v j x) atTop (𝓝 (profile (g none x))) := by
  have hc : Continuous profile := profile_contDiff.continuous
  have HH : Tendsto (fun j => profile (inverseProfile (v j) x)) atTop
      (𝓝 (profile (g none x))) := hc.continuousAt.tendsto.comp (hg.at_U [] x)
  have heq : (fun j => profile (inverseProfile (v j) x)) = fun j => v j x :=
    funext (fun j => profile_inverseProfile (hv j).2.1 x)
  change Tendsto (fun j => profile (inverseProfile (v j) x)) atTop (𝓝 (profile (g none x))) at HH
  rw [heq] at HH
  exact HH

theorem SmallDefectConverges.tensor_tangential {n : ℕ} {v : ℕ → Space n → ℝ}
    {g : SmallDefectIndex n → Space n → ℝ} (hg : SmallDefectConverges v g)
    (hv : ∀ j, v j ∈ positiveDefectClass n)
    (he : Tendsto (fun j => diffuseDefect (v j) 0) atTop (𝓝 0))
    (i : Fin n) (x : Space n) :
    ∑ k : Fin n, coordDeriv (g none) k x*g (some (some (i,k))) x = 0 := by
  have H := tendsto_finsetSum Finset.univ (fun k _ => (hg.at_U [k] x).mul (hg.at_T i k [] x))
  have H' := (hg.D_over_root_vanishes hv he [i] x).const_mul (-1/2 : ℝ)
  have heq (j : ℕ) : (∑ k : Fin n, coordinateJet (inverseProfile (v j)) [k] x*
      ((defectRoot (v j) 0)⁻¹*coordinateJet (inverseHessian (v j) i k) [] x)) =
      (-1/2 : ℝ)*((defectRoot (v j) 0)⁻¹*coordinateJet (diffuseDefect (v j)) [i] x) := by
    simp only [coordinateJet,coordDeriv_diffuseDefect_sum (hv j).1 (hv j).2.1]
    calc (∑ k : Fin n, coordDeriv (inverseProfile (v j)) k x*
        ((defectRoot (v j) 0)⁻¹*inverseHessian (v j) i k x)) =
        (defectRoot (v j) 0)⁻¹*∑ k : Fin n, coordDeriv (inverseProfile (v j)) k x*inverseHessian (v j) i k x := by
          rw [Finset.mul_sum]; apply Finset.sum_congr rfl; intro k _; ring
      _ = _ := by ring
  simp_rw [heq] at H
  simpa only [coordinateJet,mul_zero] using tendsto_nhds_unique H H'

lemma inverseHessian_transport {n : ℕ} {v : Space n → ℝ}
    (hv : ContDiff ℝ ∞ v) (hi : ∀ x, v x ∈ Set.Ioo (-1 : ℝ) 1)
    (i j : Fin n) (x : Space n) :
    (∑ k : Fin n, coordDeriv (inverseProfile v) k x*coordDeriv (inverseHessian v i j) k x) =
      -(∑ k : Fin n, inverseHessian v i k x*inverseHessian v j k x) -
        (1/2 : ℝ)*coordDeriv (coordDeriv (diffuseDefect v) i) j x := by
  have hU := inverseProfile_smooth hv hi
  have hT := inverseHessian_smooth hv hi
  have hp (k : Fin n) := coordDeriv_smooth hU k
  have hs : ContDiff ℝ ∞ (fun y => ∑ k : Fin n,
      coordDeriv (inverseProfile v) k y*inverseHessian v i k y) :=
    ContDiff.sum (fun k _ => (hp k).mul (hT i k))
  have hD : coordDeriv (diffuseDefect v) i = fun y => -2*∑ k : Fin n,
      coordDeriv (inverseProfile v) k y*inverseHessian v i k y :=
    funext (coordDeriv_diffuseDefect_sum hv hi i)
  have hm (k : Fin n) : coordDeriv (inverseHessian v i k) j = coordDeriv (inverseHessian v i j) k :=
    coordDeriv_comm (smooth_C2 (hp i)) k j
  have HH := congrArg (fun f : Space n → ℝ => coordDeriv f j x) hD
  have hscale := congrFun (coordinateJet_const_mul hs (-2) [j]) x
  simp only [coordinateJet] at hscale
  rw [hscale,coordDeriv_sum _ (fun k _ => ((hp k).mul (hT i k)).differentiable (by simp))] at HH
  simp_rw [coordDeriv_mul ((hp _).differentiable (by simp)) ((hT i _).differentiable (by simp)),hm] at HH
  have hkj (k : Fin n) : coordDeriv (coordDeriv (inverseProfile v) k) j x = inverseHessian v j k x := by
    exact congrFun (coordDeriv_comm (smooth_C2 hU) k j) x
  simp_rw [hkj] at HH
  rw [Finset.sum_add_distrib] at HH
  linarith

theorem SmallDefectConverges.tensor_transport {n : ℕ} {v : ℕ → Space n → ℝ}
    {g : SmallDefectIndex n → Space n → ℝ} (hg : SmallDefectConverges v g)
    (hv : ∀ j, v j ∈ positiveDefectClass n)
    (he : Tendsto (fun j => diffuseDefect (v j) 0) atTop (𝓝 0))
    (a b : Fin n) (x : Space n) :
    ∑ k : Fin n, coordDeriv (g none) k x*coordDeriv (g (some (some (a,b)))) k x = 0 := by
  have H := tendsto_finsetSum Finset.univ (fun k _ => (hg.at_U [k] x).mul (hg.at_T a b [k] x))
  have H0 := tendsto_finsetSum Finset.univ (fun k _ =>
    (hg.tensor_vanishes hv he a k [] x).mul (hg.at_T b k [] x))
  have HD := hg.D_over_root_vanishes hv he [b,a] x
  have HE := H0.neg.sub (HD.const_mul (1/2 : ℝ))
  have heq (j : ℕ) : (∑ k : Fin n, coordinateJet (inverseProfile (v j)) [k] x*
      ((defectRoot (v j) 0)⁻¹*coordinateJet (inverseHessian (v j) a b) [k] x)) =
      -(∑ k : Fin n, coordinateJet (inverseHessian (v j) a k) [] x*
        ((defectRoot (v j) 0)⁻¹*coordinateJet (inverseHessian (v j) b k) [] x)) -
        (1/2 : ℝ)*((defectRoot (v j) 0)⁻¹*coordinateJet (diffuseDefect (v j)) [b,a] x) := by
    simp only [coordinateJet]
    have HH := congrArg (fun r : ℝ => (defectRoot (v j) 0)⁻¹*r)
      (inverseHessian_transport (hv j).1 (hv j).2.1 a b x)
    simp only [mul_sub,mul_neg,Finset.mul_sum] at HH
    simpa only [mul_assoc,mul_left_comm,mul_comm] using HH
  simp_rw [heq] at H
  simpa only [coordinateJet,zero_mul,Finset.sum_const_zero,neg_zero,mul_zero,sub_zero]
    using tendsto_nhds_unique H HE

lemma SmallDefectConverges.D_vanishes {n : ℕ} {v : ℕ → Space n → ℝ}
    {g : SmallDefectIndex n → Space n → ℝ} (hg : SmallDefectConverges v g)
    (hv : ∀ j, v j ∈ positiveDefectClass n)
    (he : Tendsto (fun j => diffuseDefect (v j) 0) atTop (𝓝 0))
    (l : List (Fin n)) (x : Space n) :
    Tendsto (fun j => coordinateJet (diffuseDefect (v j)) l x) atTop (𝓝 0) := by
  have HH := he.mul (hg.at_D l x)
  have heq (j : ℕ) : diffuseDefect (v j) 0*((diffuseDefect (v j) 0)⁻¹*
      coordinateJet (diffuseDefect (v j)) l x) = coordinateJet (diffuseDefect (v j)) l x := by
    field_simp [((hv j).2.2.2 0).ne']
  simpa only [heq,zero_mul] using HH

lemma SmallDefectConverges.positive {n : ℕ} {v : ℕ → Space n → ℝ}
    {g : SmallDefectIndex n → Space n → ℝ} (hg : SmallDefectConverges v g)
    (hv : ∀ j, v j ∈ positiveDefectClass n) :
    g (some none) 0=1 ∧ ∀ x, 0 < g (some none) x :=
  normalized_defect_limit_positive (fun j => (hv j).1) (fun j => (hv j).2.1)
    (fun j => (hv j).2.2.1) (fun j => (hv j).2.2.2) (hg.2 (some none) [])

lemma SmallDefectConverges.tensor_trace {n : ℕ} {v : ℕ → Space n → ℝ}
    {g : SmallDefectIndex n → Space n → ℝ} (hg : SmallDefectConverges v g)
    (hv : ∀ j, v j ∈ positiveDefectClass n)
    (he : Tendsto (fun j => diffuseDefect (v j) 0) atTop (𝓝 0)) (x : Space n) :
    ∑ i : Fin n, g (some (some (i,i))) x = 0 := by
  have H := tendsto_finsetSum Finset.univ (fun i _ => hg.at_T i i [] x)
  have H' := ((hg.v_limit hv x).mul (hg.D_over_root_vanishes hv he [] x)).const_mul (-Real.sqrt 2)
  have heq (j : ℕ) : (∑ i : Fin n, (defectRoot (v j) 0)⁻¹*coordinateJet (inverseHessian (v j) i i) [] x) =
      -Real.sqrt 2*(v j x*((defectRoot (v j) 0)⁻¹*coordinateJet (diffuseDefect (v j)) [] x)) := by
    simp only [coordinateJet,← Finset.mul_sum]
    have HH := inverseProfile_laplacian_eq (smooth_C2 (hv j).1) (hv j).2.1 (hv j).2.2.1 x
    rw [laplacian_eq_sum_coordDeriv (smooth_C2 (inverseProfile_smooth (hv j).1 (hv j).2.1))] at HH
    change (∑ i : Fin n, inverseHessian (v j) i i x) = _ at HH
    rw [HH]
    ring
  simp_rw [heq] at H
  simpa only [coordinateJet,mul_zero] using tendsto_nhds_unique H H'

lemma SmallDefectConverges.controlled_over_root_vanishes {n : ℕ} {v : ℕ → Space n → ℝ}
    {g : SmallDefectIndex n → Space n → ℝ} (hg : SmallDefectConverges v g)
    (hv : ∀ j, v j ∈ positiveDefectClass n)
    (he : Tendsto (fun j => diffuseDefect (v j) 0) atTop (𝓝 0))
    {f : (Space n → ℝ) → Space n → ℝ} {k : ℕ}
    (hf : JetControl (positiveDefectClass n) diffuseDefect f k)
    (l : List (Fin n)) (hl : l.length ≤ k) (x : Space n) :
    Tendsto (fun j => (defectRoot (v j) 0)⁻¹*coordinateJet (f (v j)) l x) atTop (𝓝 0) := by
  obtain ⟨C,hC,hb⟩ := hf l hl
  apply squeeze_zero_norm (a := fun j => C*((defectRoot (v j) 0)⁻¹*diffuseDefect (v j) x))
  · intro j
    rw [Real.norm_eq_abs,abs_mul,abs_of_pos (inv_pos.mpr (defectRoot_pos (v j) 0))]
    calc _ ≤ (defectRoot (v j) 0)⁻¹*(C*diffuseDefect (v j) x) :=
      mul_le_mul_of_nonneg_left (hb (v j) (hv j) x) (inv_pos.mpr (defectRoot_pos (v j) 0)).le
      _ = _ := by ring
  · simpa only [mul_zero,coordinateJet] using (hg.D_over_root_vanishes hv he [] x).const_mul C

theorem SmallDefectConverges.tensor_harmonic {n : ℕ} {v : ℕ → Space n → ℝ}
    {g : SmallDefectIndex n → Space n → ℝ} (hg : SmallDefectConverges v g)
    (hv : ∀ j, v j ∈ positiveDefectClass n)
    (he : Tendsto (fun j => diffuseDefect (v j) 0) atTop (𝓝 0))
    (a b : Fin n) (x : Space n) :
    Laplacian.laplacian (g (some (some (a,b)))) x = 0 := by
  have hJ := positiveAC_all_jets n 2
  have hvD : JetControl (positiveDefectClass n) diffuseDefect
      (fun v x => v x*diffuseDefect v x) 2 :=
    hJ.1.mul_bounded (fun _ h => h.1) (fun _ h => diffuseDefect_smooth h.1 h.2.1)
      (fun _ h x => (h.2.2.2 x).le) hJ.2.2.1
  have HD := (hg.controlled_over_root_vanishes hv he hvD [b,a] (by simp) x).const_mul (-Real.sqrt 2)
  have H := tendsto_finsetSum Finset.univ (fun i _ => hg.at_T a b [i,i] x)
  have heq (j : ℕ) : (∑ i : Fin n, (defectRoot (v j) 0)⁻¹*
      coordinateJet (inverseHessian (v j) a b) [i,i] x) =
      -Real.sqrt 2*((defectRoot (v j) 0)⁻¹*
        coordinateJet (fun y => v j y*diffuseDefect (v j) y) [b,a] x) := by
    rw [← Finset.mul_sum]
    have hU := inverseProfile_smooth (hv j).1 (hv j).2.1
    have hTp : (∑ i : Fin n, coordinateJet (inverseHessian (v j) a b) [i,i] x) =
        Laplacian.laplacian (coordinateJet (inverseProfile (v j)) [b,a]) x :=
      (laplacian_eq_sum_coordDeriv (smooth_C2 (inverseHessian_smooth (hv j).1 (hv j).2.1 a b)) x).symm
    rw [hTp,coordinateJet_laplacian hU]
    have hLU : Laplacian.laplacian (inverseProfile (v j)) =
        fun y => -Real.sqrt 2*(v j y*diffuseDefect (v j) y) := by
      funext y
      rw [inverseProfile_laplacian_eq (smooth_C2 (hv j).1) (hv j).2.1 (hv j).2.2.1]
      ring
    rw [hLU,coordinateJet_const_mul ((hv j).1.mul (diffuseDefect_smooth (hv j).1 (hv j).2.1))]
    ring
  simp_rw [heq] at H
  have HH := tendsto_nhds_unique H HD
  rw [laplacian_eq_sum_coordDeriv (smooth_C2 (hg.1 (some (some (a,b)))))]
  simpa only [coordinateJet,mul_zero] using HH

lemma normalized_defect_equation {n : ℕ} {v : Space n → ℝ} (hv : v ∈ positiveDefectClass n)
    (x : Space n) :
    (diffuseDefect v 0)⁻¹*Laplacian.laplacian (diffuseDefect v) x =
      -2*(∑ i : Fin n, ∑ j : Fin n, ((defectRoot v 0)⁻¹*inverseHessian v i j x)^2) +
        2*Real.sqrt 2*v x*(∑ k : Fin n, coordDeriv (inverseProfile v) k x*
          ((diffuseDefect v 0)⁻¹*coordDeriv (diffuseDefect v) k x)) +
        2*(1-v x^2)*((diffuseDefect v 0)⁻¹*diffuseDefect v x)*(1-diffuseDefect v x) := by
  have hsq : (∑ i : Fin n, ∑ j : Fin n, ((defectRoot v 0)⁻¹*inverseHessian v i j x)^2) =
      (diffuseDefect v 0)⁻¹*hessianSquare v x := by
    rw [hessianSquare_eq_sum,Finset.mul_sum]
    apply Finset.sum_congr rfl
    intro i _
    rw [Finset.mul_sum]
    apply Finset.sum_congr rfl
    intro j _
    rw [← defectRoot_sq (hv.2.2.2 0)]
    ring
  have hp : (∑ k : Fin n, coordDeriv (inverseProfile v) k x*
      ((diffuseDefect v 0)⁻¹*coordDeriv (diffuseDefect v) k x)) =
      (diffuseDefect v 0)⁻¹*inner ℝ (gradient (inverseProfile v) x) (gradient (diffuseDefect v) x) := by
    rw [inner_gradient_eq_sum,Finset.mul_sum]
    apply Finset.sum_congr rfl
    intro k _
    ring
  rw [diffuseDefect_laplacian hv.1 hv.2.1 hv.2.2.1,hsq,hp]
  change (diffuseDefect v 0)⁻¹*(-2*hessianSquare v x+_+_) = _
  dsimp only [defectWeight,diffuseDefect]
  ring

theorem SmallDefectConverges.defect_equation {n : ℕ} {v : ℕ → Space n → ℝ}
    {g : SmallDefectIndex n → Space n → ℝ} (hg : SmallDefectConverges v g)
    (hv : ∀ j, v j ∈ positiveDefectClass n)
    (he : Tendsto (fun j => diffuseDefect (v j) 0) atTop (𝓝 0)) (x : Space n) :
    Laplacian.laplacian (g (some none)) x =
      -2*(∑ i : Fin n, ∑ j : Fin n, (g (some (some (i,j))) x)^2) +
        2*Real.sqrt 2*profile (g none x)*(∑ k : Fin n, coordDeriv (g none) k x*
          coordDeriv (g (some none)) k x) +
        2*(1-profile (g none x)^2)*g (some none) x := by
  have HL := tendsto_finsetSum Finset.univ (fun i _ => hg.at_D [i,i] x)
  have HS := tendsto_finsetSum Finset.univ (fun i _ =>
    tendsto_finsetSum Finset.univ (fun j _ => (hg.at_T i j [] x).pow 2))
  have HP := tendsto_finsetSum Finset.univ (fun k _ => (hg.at_U [k] x).mul (hg.at_D [k] x))
  have HV := hg.v_limit hv x
  have HQ := (tendsto_const_nhds (x := (1 : ℝ))).sub (HV.pow 2)
  have HZ := (tendsto_const_nhds (x := (1 : ℝ))).sub (hg.D_vanishes hv he [] x)
  have HD := hg.at_D [] x
  have HR := ((HS.const_mul (-2 : ℝ)).add ((HV.const_mul (2*Real.sqrt 2)).mul HP)).add
    (((HQ.const_mul 2).mul HD).mul HZ)
  have heq (j : ℕ) : (∑ i : Fin n, (diffuseDefect (v j) 0)⁻¹*coordinateJet (diffuseDefect (v j)) [i,i] x) =
      -2*(∑ i : Fin n, ∑ k : Fin n, ((defectRoot (v j) 0)⁻¹*coordinateJet (inverseHessian (v j) i k) [] x)^2) +
        2*Real.sqrt 2*v j x*(∑ k : Fin n, coordinateJet (inverseProfile (v j)) [k] x*
          ((diffuseDefect (v j) 0)⁻¹*coordinateJet (diffuseDefect (v j)) [k] x)) +
        2*(1-v j x^2)*((diffuseDefect (v j) 0)⁻¹*coordinateJet (diffuseDefect (v j)) [] x)*
          (1-coordinateJet (diffuseDefect (v j)) [] x) := by
    rw [← Finset.mul_sum]
    simp only [coordinateJet]
    rw [← laplacian_eq_sum_coordDeriv (smooth_C2 (diffuseDefect_smooth (hv j).1 (hv j).2.1))]
    exact normalized_defect_equation (hv j) x
  simp_rw [heq] at HL
  have HH := tendsto_nhds_unique HL HR
  rw [laplacian_eq_sum_coordDeriv (smooth_C2 (hg.1 (some none)))]
  simpa only [coordinateJet,sub_zero,mul_one] using HH

def profileWeight (s : ℝ) : ℝ := 1-profile s^2

lemma profile_hasDerivAt (s : ℝ) :
    HasDerivAt profile (profileWeight s/Real.sqrt 2) s := by
  let y := s/Real.sqrt 2
  have H := (Real.hasDerivAt_sinh y).div (Real.hasDerivAt_cosh y) (Real.cosh_pos y).ne'
  have he : (Real.cosh y*Real.cosh y-Real.sinh y*Real.sinh y)/Real.cosh y^2 =
      1-Real.tanh y^2 := by
    rw [Real.tanh_eq_sinh_div_cosh]
    field_simp
  change HasDerivAt (fun z => Real.sinh z/Real.cosh z)
    ((Real.cosh y*Real.cosh y-Real.sinh y*Real.sinh y)/Real.cosh y^2) y at H
  rw [he,← funext Real.tanh_eq_sinh_div_cosh] at H
  have HH := H.comp s ((hasDerivAt_id s).div_const (Real.sqrt 2))
  change HasDerivAt (fun s => Real.tanh (s/Real.sqrt 2)) _ s
  simpa only [Function.comp_def,id_eq,profileWeight,profile,y,div_eq_mul_inv,one_mul] using HH

lemma profileWeight_contDiff : ContDiff ℝ ∞ profileWeight :=
  contDiff_const.sub (profile_contDiff.pow 2)

lemma profileWeight_pos (s : ℝ) : 0 < profileWeight s := by
  dsimp [profileWeight,profile]
  linarith [Real.tanh_sq_lt_one (s/Real.sqrt 2)]

lemma profileWeight_hasDerivAt (s : ℝ) :
    HasDerivAt profileWeight (-Real.sqrt 2*profile s*profileWeight s) s := by
  have H := (hasDerivAt_const s (1 : ℝ)).sub ((profile_hasDerivAt s).pow 2)
  have he : (0 : ℝ)-2*profile s^(2-1)*(profileWeight s/Real.sqrt 2) =
      -Real.sqrt 2*profile s*profileWeight s := by
    have hsq := Real.sq_sqrt (by norm_num : (0 : ℝ) ≤ 2)
    have hs : Real.sqrt 2 ≠ 0 := (Real.sqrt_pos.mpr (by norm_num : (0 : ℝ) < 2)).ne'
    norm_num only [Nat.reduceSub,pow_one,zero_sub]
    field_simp
    rw [hsq]
    ring
  change HasDerivAt profileWeight (0-2*profile s^(2-1)*(profileWeight s/Real.sqrt 2)) s at H
  rwa [he] at H

lemma profileWeight_hasDerivAt_twice (s : ℝ) :
    HasDerivAt (deriv profileWeight) ((3*profile s^2-1)*profileWeight s) s := by
  have H := ((profile_hasDerivAt s).mul (profileWeight_hasDerivAt s)).const_mul (-Real.sqrt 2)
  have he : -Real.sqrt 2*(profileWeight s/Real.sqrt 2*profileWeight s+
       profile s*(-Real.sqrt 2*profile s*profileWeight s)) =
       (3*profile s^2-1)*profileWeight s := by
    have hs : Real.sqrt 2 ≠ 0 := (Real.sqrt_pos.mpr (by norm_num : (0 : ℝ) < 2)).ne'
    have hsq := Real.sq_sqrt (by norm_num : (0 : ℝ) ≤ 2)
    field_simp
    dsimp [profileWeight]
    nlinarith [congrArg (fun r : ℝ => r*(profile s^2)*(1-profile s^2)) hsq]
  have hfun : deriv profileWeight = fun s => -Real.sqrt 2*(profile s*profileWeight s) := by
    funext s
    rw [(profileWeight_hasDerivAt s).deriv]
    ring
  rw [hfun]
  rw [he] at H
  simpa only [Pi.mul_apply] using H

lemma gradient_comp_inner {n : ℕ} {f : ℝ → ℝ} (hf : Differentiable ℝ f)
    (c x : Space n) : gradient (fun z => f (inner ℝ c z)) x = deriv f (inner ℝ c x) • c := by
  have H := (hf (inner ℝ c x)).hasDerivAt.comp_hasFDerivAt x (innerSL ℝ c).hasFDerivAt
  change HasFDerivAt (fun z : Space n => f (inner ℝ c z))
    (deriv f (inner ℝ c x) • innerSL ℝ c) x at H
  apply ext_inner_right ℝ
  intro z
  rw [inner_gradient_left, H.fderiv, real_inner_smul_left]
  simp only [smul_apply, smul_eq_mul, innerSL_apply_apply]

lemma gradient_inner {n : ℕ} (c x : Space n) : gradient (fun z => inner ℝ c z) x = c := by
  have H := gradient_comp_inner (f := id) differentiable_id c x
  simpa using H

lemma laplacian_inner {n : ℕ} (c x : Space n) :
    Laplacian.laplacian (fun z => inner ℝ c z) x = 0 := by
  simpa only [zero_add] using PoissonSupport.DeGiorgi.laplacian_affine c 0 x

end DeGiorgi
end

end OAI