import OAI.Analysis.AllenCahn.PoissonMaximum

namespace OAI

noncomputable section
namespace PoissonSupport.DeGiorgi
open MeasureTheory
open scoped ENNReal
open Filter Topology

lemma laplacian_poisson_at_max {n : ℕ} {f : Space n → ℝ}
    (hf : ContDiff ℝ 2 f) (A ε : ℝ) {x y : Space n}
    (hxy : y ≠ x) (hsmall : ‖y - x‖ < 1)
    (hm : ∀ a b : Space n,
      f b - f a - poissonPenalty A ‖b - a‖ - ε * (‖a‖ ^ 2 + ‖b‖ ^ 2) ≤
      f y - f x - poissonPenalty A ‖y - x‖ - ε * (‖x‖ ^ 2 + ‖y‖ ^ 2)) :
    Laplacian.laplacian f y - Laplacian.laplacian f x ≤ -8 * A + 4 * n * ε := by
  let r := ‖y - x‖
  have hr : 0 < r := norm_pos_iff.mpr (sub_ne_zero.mpr hxy)
  let e : Space n := r⁻¹ • (y - x)
  have he : ‖e‖ = 1 := by simp [e, norm_smul, r, hr.ne']
  have her : r • e = y - x := by dsimp [e]; rw [smul_smul, mul_inv_cancel₀ hr.ne', one_smul]
  let J := reflect e
  let a : Space n := (-2 : ℝ) • e
  let g : Space n → ℝ := fun z => r + inner ℝ a z
  have hg : ContDiff ℝ 2 g := contDiff_const.add (innerSL ℝ a).contDiff
  have hg0 : g 0 = r := by simp [g]
  have hdistance : ∀ z : Space n, y + J z - (x + z) = g z • e := by
    intro z
    have hai : inner ℝ a z = (-2 : ℝ) * inner ℝ e z := by
      dsimp only [a]
      rw [real_inner_smul_left]
    change y + reflect e z - (x + z) = (r + inner ℝ a z) • e
    rw [reflect_apply he, hai, add_smul, her, neg_mul, neg_smul]
    abel
  have hnear : ∀ᶠ z in 𝓝 (0 : Space n), 0 < g z ∧ g z < 1 :=
    ((hg.continuous.isOpen_preimage _ isOpen_Ioo).mem_nhds (by simpa [hg0] using And.intro hr hsmall))
  let F : Space n → ℝ := fun z => f (y + J z) - f (x + z) -
    A * (2 * g z - (g z) ^ 2) - ε * (‖x + z‖ ^ 2 + ‖y + J z‖ ^ 2)
  have hfy : ContDiff ℝ 2 (fun z => f (y + J z)) :=
    hf.comp (contDiff_const.add J.contDiff)
  have hfx : ContDiff ℝ 2 (fun z => f (x + z)) := hf.comp (contDiff_const.add contDiff_id)
  have hnx : ContDiff ℝ 2 (fun z : Space n => ‖x + z‖ ^ 2) :=
    (contDiff_const.add contDiff_id).norm_sq ℝ
  have hny : ContDiff ℝ 2 (fun z : Space n => ‖y + J z‖ ^ 2) :=
    (contDiff_const.add J.contDiff).norm_sq ℝ
  have hp : ContDiff ℝ 2 (fun z => A * (2 * g z - (g z) ^ 2)) := by fun_prop
  have hq : ContDiff ℝ 2 (fun z => ε * (‖x + z‖ ^ 2 + ‖y + J z‖ ^ 2)) := by fun_prop
  have hF : ContDiff ℝ 2 F := ((hfy.sub hfx).sub hp).sub hq
  have hmax : IsLocalMax F 0 := by
    filter_upwards [hnear] with z hz
    have hnorm : ‖y + J z - (x + z)‖ = g z := by
      rw [hdistance, norm_smul, he, mul_one, Real.norm_eq_abs, abs_of_pos hz.1]
    have hh := hm (x + z) (y + J z)
    rw [hnorm, poissonPenalty_of_le A hz.2.le, poissonPenalty_of_le A hsmall.le] at hh
    simpa [F, hg0, r] using hh
  have hl := laplacian_nonpos_of_local_max hF hmax
  have hly : Laplacian.laplacian (fun z => f (y + J z)) 0 = Laplacian.laplacian f y := by
    have ht : ContDiff ℝ 2 (fun u => f (y + u)) := hf.comp (contDiff_const.add contDiff_id)
    simpa only [map_zero, laplacian_translate hf, add_zero] using laplacian_comp_isometry ht J 0
  have hns : ContDiff ℝ 2 (fun z : Space n => ‖z‖ ^ 2) := contDiff_id.norm_sq ℝ
  have hlny : Laplacian.laplacian (fun z => ‖y + J z‖ ^ 2) 0 = 2 * n := by
    have ht : ContDiff ℝ 2 (fun u : Space n => ‖y + u‖ ^ 2) :=
      (contDiff_const.add contDiff_id).norm_sq ℝ
    simpa only [map_zero, laplacian_translate hns, laplacian_norm_sq] using
      laplacian_comp_isometry ht J 0
  have hal : ‖a‖ ^ 2 = 4 := by simp [a, norm_smul, he]; norm_num
  have hlg : Laplacian.laplacian g 0 = 0 := laplacian_affine a r 0
  have hlgs : Laplacian.laplacian (fun z => g z ^ 2) 0 = 8 := by
    rw [show (fun z => g z ^ 2) = (fun z => (r + inner ℝ a z) ^ 2) from rfl,
      laplacian_affine_sq, hal]
    norm_num
  have hg2 : ContDiff ℝ 2 (fun z => 2 * g z) := contDiff_const.mul hg
  dsimp only [F] at hl
  rw [laplacian_fun_sub ((hfy.sub hfx).sub hp) hq,
    laplacian_fun_sub (hfy.sub hfx) hp, laplacian_fun_sub hfy hfx,
    hly, laplacian_translate hf,
    laplacian_fun_const_mul (hg2.sub (hg.pow 2)),
    laplacian_fun_sub hg2 (hg.pow 2),
    laplacian_fun_const_mul hg, hlg, hlgs,
    laplacian_fun_const_mul (hnx.add hny), laplacian_fun_add hnx hny,
    laplacian_translate hns, laplacian_norm_sq, hlny] at hl
  simp only [add_zero] at hl
  linarith

lemma bounded_poisson_lipschitz {n : ℕ} {f : Space n → ℝ}
    (hf : ContDiff ℝ 2 f) {M C : ℝ} (hM : 0 ≤ M) (hC : 0 ≤ C)
    (hbound : ∀ x, |f x| ≤ M) (hlap : ∀ x, |Laplacian.laplacian f x| ≤ C) :
    ∀ x y, |f y - f x| ≤ 2 * (2 * M + C + 1) * ‖y - x‖ := by
  let A := 2 * M + C + 1
  have hA : 0 < A := by dsimp [A]; positivity
  have hlarge : 2 * M < A := by dsimp [A]; linarith
  have honeway : ∀ x y, f y - f x ≤ 2 * A * ‖y - x‖ := by
    intro x₀ y₀
    by_contra hbad
    have hbad' : 2 * A * ‖y₀ - x₀‖ < f y₀ - f x₀ := lt_of_not_ge hbad
    let δ := f y₀ - f x₀ - poissonPenalty A ‖y₀ - x₀‖
    have hδ : 0 < δ := by
      dsimp [δ]
      have hh := poissonPenalty_le_linear hA.le (norm_nonneg (y₀ - x₀))
      linarith
    let S := ‖x₀‖ ^ 2 + ‖y₀‖ ^ 2
    have hS : 0 ≤ S := by dsimp [S]; positivity
    let ε := min (δ / (2 * (S + 1))) (1 / (n + 1 : ℝ))
    have hε : 0 < ε := lt_min (by positivity) (by positivity)
    have hεS : ε * (S + 1) ≤ δ / 2 := by
      have hh := min_le_left (δ / (2 * (S + 1))) (1 / (n + 1 : ℝ))
      have hh' := (le_div_iff₀ (show 0 < 2 * (S + 1) by positivity)).mp hh
      change ε * (2 * (S + 1)) ≤ δ at hh'
      linarith
    have hεn : (n : ℝ) * ε ≤ 1 := by
      have hh := min_le_right (δ / (2 * (S + 1))) (1 / (n + 1 : ℝ))
      have hh' := (le_div_iff₀ (show 0 < (n : ℝ) + 1 by positivity)).mp hh
      change ε * ((n : ℝ) + 1) ≤ 1 at hh'
      nlinarith
    have hpos₀ : 0 < f y₀ - f x₀ - poissonPenalty A ‖y₀ - x₀‖ -
        ε * (‖x₀‖ ^ 2 + ‖y₀‖ ^ 2) := by
      change 0 < δ - ε * S
      nlinarith
    obtain ⟨x, y, hm⟩ := poisson_maximum hf.continuous hM hbound hA.le hε
    have hp : 0 < f y - f x - poissonPenalty A ‖y - x‖ - ε * (‖x‖ ^ 2 + ‖y‖ ^ 2) :=
      hpos₀.trans_le (hm x₀ y₀)
    have hpen : 0 ≤ ε * (‖x‖ ^ 2 + ‖y‖ ^ 2) := by positivity
    have hxy : y ≠ x := by
      rintro rfl
      simp only [sub_self, norm_zero, poissonPenalty, sub_zero, max_eq_left zero_le_one,
        one_pow, sub_self, mul_zero] at hp
      linarith
    have hs : ‖y - x‖ < 1 := by
      by_contra h
      rw [poissonPenalty_of_ge A (le_of_not_gt h)] at hp
      have hb₁ := (abs_le.mp (hbound x)).1
      have hb₂ := (abs_le.mp (hbound y)).2
      linarith
    have hl := laplacian_poisson_at_max hf A ε hxy hs hm
    have hb₁ := (abs_le.mp (hlap y)).1
    have hb₂ := (abs_le.mp (hlap x)).2
    dsimp [A] at hl
    linarith
  intro x y
  apply abs_le.mpr
  constructor
  · have h := honeway y x
    rw [norm_sub_rev x y] at h
    linarith
  · exact honeway x y

lemma gradient_poisson_at_max_y {n : ℕ} {f : Space n → ℝ}
    (hf : Differentiable ℝ f) (A ε : ℝ) {x y : Space n}
    (hxy : y ≠ x) (hs : ‖y - x‖ < 1)
    (hm : ∀ b : Space n,
      f b - f x - poissonPenalty A ‖b - x‖ - ε * (‖x‖ ^ 2 + ‖b‖ ^ 2) ≤
      f y - f x - poissonPenalty A ‖y - x‖ - ε * (‖x‖ ^ 2 + ‖y‖ ^ 2)) :
    gradient f y = (2 * A * (1 - ‖y - x‖) / ‖y - x‖) • (y - x) +
      (2 * ε) • y := by
  have hn : HasFDerivAt (fun b : Space n => ‖b - x‖)
      (‖y - x‖⁻¹ • innerSL ℝ (y - x)) y := by
    simpa only [Function.comp_def, ContinuousLinearMap.comp_id, id_eq] using
      (hasFDerivAt_norm_nonzero (sub_ne_zero.mpr hxy)).comp y
      ((hasFDerivAt_id y).sub_const x)
  have hq : HasFDerivAt (fun b : Space n => ‖x‖ ^ 2 + ‖b‖ ^ 2)
      ((2 : ℝ) • innerSL ℝ y) y := by
    have hh := (hasStrictFDerivAt_norm_sq y).hasFDerivAt.const_add (‖x‖ ^ 2)
    rw [← Nat.cast_smul_eq_nsmul ℝ 2, Nat.cast_ofNat] at hh
    exact hh
  have hp := ((hn.const_mul 2).sub (hn.pow 2)).const_mul A
  have hd := (((hf y).hasFDerivAt.sub_const (f x)).fun_sub hp).fun_sub (hq.const_mul ε)
  have hnear : ∀ᶠ b : Space n in 𝓝 y, ‖b - x‖ < 1 :=
    (isOpen_lt (continuous_id.sub continuous_const).norm continuous_const).mem_nhds hs
  have hmax : IsLocalMax (fun b : Space n => f b - f x -
      A * (2 * ‖b - x‖ - ‖b - x‖ ^ 2) - ε * (‖x‖ ^ 2 + ‖b‖ ^ 2)) y := by
    filter_upwards [hnear] with b hb
    simpa only [poissonPenalty_of_le A hb.le, poissonPenalty_of_le A hs.le] using hm b
  have hz := hmax.hasFDerivAt_eq_zero hd
  apply (InnerProductSpace.toDual ℝ (Space n)).injective
  ext z
  have he := congrArg (fun L : Space n →L[ℝ] ℝ => L z) hz
  simp only [sub_apply, smul_apply, smul_eq_mul, zero_apply, pow_one,
    Nat.cast_ofNat, Nat.reduceSub, nsmul_eq_mul, innerSL_apply_apply] at he
  simp only [toDual_gradient, map_add, map_smul, add_apply, smul_apply,
    InnerProductSpace.toDual_apply_apply, smul_eq_mul]
  change (fderiv ℝ f y) z = _
  change (fderiv ℝ f y) z - A * (2 * (‖y - x‖⁻¹ * inner ℝ (y - x) z) -
    (2 * ‖y - x‖) * (‖y - x‖⁻¹ * inner ℝ (y - x) z)) -
    ε * (2 * inner ℝ y z) = 0 at he
  rw [div_eq_mul_inv]
  nlinarith

lemma poisson_gradient_bounds {n : ℕ} {f : Space n → ℝ}
    (hf : Differentiable ℝ f) {M A ε : ℝ} (hM : 0 ≤ M)
    (hbound : ∀ x, |f x| ≤ M) (hA : 0 ≤ A) (hε : 0 < ε)
    {x y : Space n} (hxy : y ≠ x) (hs : ‖y - x‖ < 1)
    (hpos : 0 < f y - f x - poissonPenalty A ‖y - x‖ - ε * (‖x‖ ^ 2 + ‖y‖ ^ 2))
    (hm : ∀ a b : Space n,
      f b - f a - poissonPenalty A ‖b - a‖ - ε * (‖a‖ ^ 2 + ‖b‖ ^ 2) ≤
      f y - f x - poissonPenalty A ‖y - x‖ - ε * (‖x‖ ^ 2 + ‖y‖ ^ 2)) :
    ‖gradient f x‖ ≤ 2 * A + 2 * Real.sqrt (2 * M * ε) ∧
      ‖gradient f y‖ ≤ 2 * A + 2 * Real.sqrt (2 * M * ε) := by
  have hpen : ε * (‖x‖ ^ 2 + ‖y‖ ^ 2) ≤ 2 * M := by
    have hx := (abs_le.mp (hbound x)).1
    have hy := (abs_le.mp (hbound y)).2
    have hz := poissonPenalty_nonneg hA (norm_nonneg (y - x))
    linarith
  have hsmall : ∀ z : Space n, ε * ‖z‖ ^ 2 ≤ 2 * M →
      ‖(2 * ε) • z‖ ≤ 2 * Real.sqrt (2 * M * ε) := by
    intro z hz
    rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg (by positivity : 0 ≤ 2 * ε)]
    have hsq := Real.sq_sqrt (show 0 ≤ 2 * M * ε by positivity)
    have hc := mul_le_mul_of_nonneg_right hz hε.le
    nlinarith [Real.sqrt_nonneg (2 * M * ε), norm_nonneg z]
  have hxsmall := hsmall x (by nlinarith [mul_nonneg hε.le (sq_nonneg ‖y‖)])
  have hysmall := hsmall y (by nlinarith [mul_nonneg hε.le (sq_nonneg ‖x‖)])
  have hpbound {a b : Space n} (hab : b ≠ a) (hr : ‖b - a‖ < 1) :
      ‖(2 * A * (1 - ‖b - a‖) / ‖b - a‖) • (b - a)‖ ≤ 2 * A := by
    rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg (by positivity),
      div_mul_cancel₀ _ (norm_ne_zero_iff.mpr (sub_ne_zero.mpr hab))]
    nlinarith [norm_nonneg (b - a)]
  have hgy := gradient_poisson_at_max_y hf A ε hxy hs (hm x)
  have hnegmax : ∀ a b : Space n,
      -f b - -f a - poissonPenalty A ‖b - a‖ - ε * (‖a‖ ^ 2 + ‖b‖ ^ 2) ≤
      -f x - -f y - poissonPenalty A ‖x - y‖ - ε * (‖y‖ ^ 2 + ‖x‖ ^ 2) := by
    intro a b
    simpa only [neg_sub_neg, norm_sub_rev, add_comm] using hm b a
  have hgx := gradient_poisson_at_max_y hf.neg A ε (Ne.symm hxy)
    (by simpa only [norm_sub_rev] using hs) (hnegmax y)
  have hng : gradient (fun z => -f z) x = -gradient f x := by
    simp only [gradient, fderiv_fun_neg, map_neg]
  change gradient (fun z => -f z) x = _ at hgx
  rw [hng] at hgx
  constructor
  · calc ‖gradient f x‖ = ‖-gradient f x‖ := (norm_neg _).symm
         _ = ‖(2 * A * (1 - ‖x - y‖) / ‖x - y‖) • (x - y) + (2 * ε) • x‖ := congrArg norm hgx
         _ ≤ _ := (norm_add_le _ _).trans (add_le_add
           (hpbound (Ne.symm hxy) (by simpa only [norm_sub_rev] using hs)) hxsmall)
  · rw [hgy]
    exact (norm_add_le _ _).trans (add_le_add (hpbound hxy hs) hysmall)

lemma bounded_unit_drift_lipschitz {n : ℕ} {f : Space n → ℝ}
    (hf : ContDiff ℝ 2 f) (b : Space n → Space n) {M C : ℝ}
    (hM : 0 ≤ M) (hC : 0 ≤ C) (hbound : ∀ x, |f x| ≤ M)
    (hb : ∀ x, ‖b x‖ ≤ 1)
    (hpde : ∀ x, |Laplacian.laplacian f x - fderiv ℝ f x (b x)| ≤ C) :
    ∀ x y, |f y - f x| ≤ 2 * (2 * M + C + 3) * ‖y - x‖ := by
  let A := 2 * M + C + 3
  have hA : 0 < A := by dsimp [A]; positivity
  have hlarge : 2 * M < A := by dsimp [A]; linarith
  have honeway : ∀ x y, f y - f x ≤ 2 * A * ‖y - x‖ := by
    intro x₀ y₀
    by_contra hbad
    have hbad' : 2 * A * ‖y₀ - x₀‖ < f y₀ - f x₀ := lt_of_not_ge hbad
    let δ := f y₀ - f x₀ - poissonPenalty A ‖y₀ - x₀‖
    have hδ : 0 < δ := by
      dsimp [δ]
      have hh := poissonPenalty_le_linear hA.le (norm_nonneg (y₀ - x₀))
      linarith
    let S := ‖x₀‖ ^ 2 + ‖y₀‖ ^ 2
    have hS : 0 ≤ S := by dsimp [S]; positivity
    let ε := min (δ / (2 * (S + 1))) (min (1 / (n + 1 : ℝ)) (1 / (8 * M + 1)))
    have hε : 0 < ε := lt_min (by positivity) (lt_min (by positivity) (by positivity))
    have hεS : ε * (S + 1) ≤ δ / 2 := by
      have hh := min_le_left (δ / (2 * (S + 1))) (min (1 / (n + 1 : ℝ)) (1 / (8 * M + 1)))
      have hh' := (le_div_iff₀ (show 0 < 2 * (S + 1) by positivity)).mp hh
      change ε * (2 * (S + 1)) ≤ δ at hh'
      linarith
    have hεn : (n : ℝ) * ε ≤ 1 := by
      have hh : ε ≤ 1 / (n + 1 : ℝ) := (min_le_right _ _).trans (min_le_left _ _)
      have hh' := (le_div_iff₀ (show 0 < (n : ℝ) + 1 by positivity)).mp hh
      nlinarith
    have hεM : 2 * Real.sqrt (2 * M * ε) ≤ 1 := by
      have hh : ε ≤ 1 / (8 * M + 1) := (min_le_right _ _).trans (min_le_right _ _)
      have hh' := (le_div_iff₀ (show 0 < 8 * M + 1 by positivity)).mp hh
      have hs := Real.sq_sqrt (show 0 ≤ 2 * M * ε by positivity)
      nlinarith [Real.sqrt_nonneg (2 * M * ε)]
    have hpos₀ : 0 < f y₀ - f x₀ - poissonPenalty A ‖y₀ - x₀‖ -
        ε * (‖x₀‖ ^ 2 + ‖y₀‖ ^ 2) := by
      change 0 < δ - ε * S
      nlinarith
    obtain ⟨x, y, hm⟩ := poisson_maximum hf.continuous hM hbound hA.le hε
    have hp : 0 < f y - f x - poissonPenalty A ‖y - x‖ - ε * (‖x‖ ^ 2 + ‖y‖ ^ 2) :=
      hpos₀.trans_le (hm x₀ y₀)
    have hpen : 0 ≤ ε * (‖x‖ ^ 2 + ‖y‖ ^ 2) := by positivity
    have hxy : y ≠ x := by
      rintro rfl
      simp only [sub_self, norm_zero, poissonPenalty, sub_zero, max_eq_left zero_le_one,
        one_pow, sub_self, mul_zero] at hp
      linarith
    have hs : ‖y - x‖ < 1 := by
      by_contra h
      rw [poissonPenalty_of_ge A (le_of_not_gt h)] at hp
      have hb₁ := (abs_le.mp (hbound x)).1
      have hb₂ := (abs_le.mp (hbound y)).2
      linarith
    have hl := laplacian_poisson_at_max hf A ε hxy hs hm
    have hg := poisson_gradient_bounds (hf.differentiable (by norm_num)) hM hbound hA.le hε hxy hs hp hm
    have hdr (z : Space n) : |fderiv ℝ f z (b z)| ≤ ‖gradient f z‖ := by
      rw [← toDual_gradient]
      change |inner ℝ (gradient f z) (b z)| ≤ _
      exact (abs_real_inner_le_norm _ _).trans (by nlinarith [norm_nonneg (gradient f z), hb z])
    have hx := (abs_le.mp (hpde x)).2
    have hy := (abs_le.mp (hpde y)).1
    have hd₁ := (abs_le.mp (hdr x)).2
    have hd₂ := (abs_le.mp (hdr y)).1
    dsimp [A] at *
    linarith
  intro x y
  apply abs_le.mpr
  constructor
  · have h := honeway y x
    rw [norm_sub_rev x y] at h
    linarith
  · exact honeway x y

lemma fderiv_dilation {n : ℕ} {f : Space n → ℝ} (hf : Differentiable ℝ f)
    (r : ℝ) (x a : Space n) :
    fderiv ℝ (fun z => f (r • z)) x a = r * fderiv ℝ f (r • x) a := by
  have hd : HasFDerivAt (fun z => f (r • z))
      ((fderiv ℝ f (r • x)).comp (r • ContinuousLinearMap.id ℝ (Space n))) x := by
    simpa only [Function.comp_def, id_eq] using
      (hf (r • x)).hasFDerivAt.comp x ((hasFDerivAt_id x).const_smul r)
  rw [hd.fderiv]
  simp

lemma coordDeriv_dilation {n : ℕ} {f : Space n → ℝ} (hf : Differentiable ℝ f)
    (r : ℝ) (i : Fin n) (x : Space n) :
    coordDeriv (fun z => f (r • z)) i x = r * coordDeriv f i (r • x) :=
  fderiv_dilation hf r x (basis n i)

lemma coordDeriv_const_mul {n : ℕ} {f : Space n → ℝ} (hf : Differentiable ℝ f)
    (r : ℝ) (i : Fin n) (x : Space n) :
    coordDeriv (fun z => r * f z) i x = r * coordDeriv f i x := by
  dsimp [coordDeriv]
  rw [fderiv_const_mul (hf x)]
  simp

lemma laplacian_dilation {n : ℕ} {f : Space n → ℝ} (hf : ContDiff ℝ 2 f)
    (r : ℝ) (x : Space n) :
    Laplacian.laplacian (fun z => f (r • z)) x = r ^ 2 * Laplacian.laplacian f (r • x) := by
  have hc : ContDiff ℝ 2 (fun z => f (r • z)) := hf.comp (contDiff_id.const_smul r)
  rw [laplacian_eq_sum_coordDeriv hc, laplacian_eq_sum_coordDeriv hf, Finset.mul_sum]
  apply Finset.sum_congr rfl
  intro i _
  have he : coordDeriv (fun z => f (r • z)) i = fun z => r * coordDeriv f i (r • z) :=
    funext (coordDeriv_dilation (hf.differentiable (by norm_num)) r i)
  have hd : Differentiable ℝ (fun z => coordDeriv f i (r • z)) :=
    ((coordDeriv_contDiff hf i).differentiable (by norm_num)).comp (differentiable_id.const_smul r)
  rw [he, coordDeriv_const_mul hd,
    coordDeriv_dilation ((coordDeriv_contDiff hf i).differentiable (by norm_num))]
  ring

end PoissonSupport.DeGiorgi
end

end OAI