import OAI.Analysis.AllenCahn.Bernstein

namespace OAI

noncomputable section
namespace DeGiorgi
open scoped ContDiff
open Filter Topology

def derivativeDefectConstant (n : ℕ) : ℝ :=
  carrierScale n * (2 * tensorSecondBernsteinConstant n +
    2 * (2 + tensorBernsteinConstant n * (tensorBernsteinConstant n + 4) / carrierScale n) + 1)

lemma derivativeDefectConstant_pos (n : ℕ) : 0 < derivativeDefectConstant n := by
  have hB : 0 ≤ tensorBernsteinConstant n := by dsimp [tensorBernsteinConstant]; positivity
  have hA := tensorSecondBernsteinConstant_pos n
  have hs := carrierScale_pos n
  dsimp [derivativeDefectConstant]; positivity

theorem tensorDerivativeSquare_le_defect {n : ℕ} {v : Space n → ℝ}
    (hv : ContDiff ℝ ∞ v) (hi : ∀ x, v x ∈ Set.Ioo (-1 : ℝ) 1) (hAC : AllenCahn v)
    (x : Space n) : tensorDerivativeSquare v x ≤ derivativeDefectConstant n * diffuseDefect v x := by
  let a := carrierScale n
  let f := fun y => tensorDerivativeSquare v y / a
  let c := 2 * (2 + tensorBernsteinConstant n * (tensorBernsteinConstant n + 4) / a)
  have ha : 0 < a := carrierScale_pos n
  have ha1 : 1 ≤ a := by
    have hh : 0 ≤ tensorBernsteinConstant n := by dsimp [tensorBernsteinConstant]; positivity
    dsimp [a, carrierScale]; linarith
  have hA := tensorSecondBernsteinConstant_pos n
  have hB : 0 ≤ tensorBernsteinConstant n := by dsimp [tensorBernsteinConstant]; positivity
  have hJ : 0 ≤ inverseJetConstant n := (by norm_num : (0 : ℝ) ≤ 1).trans (inverseJetConstant_one_le n)
  have hf : ContDiff ℝ 2 f := (smooth_C2 (tensorDerivativeSquare_smooth hv hi)).div_const _
  have hc : 0 ≤ c := by dsimp [c]; positivity
  have hfde (y : Space n) : - (2 * tensorSecondBernsteinConstant n) * (f y + defectCarrier v y) ≤
      Laplacian.laplacian f y - fderiv ℝ f y (diffuseDrift v y) := by
    have hLow := div_le_div_of_nonneg_right (tensorDerivativeSquare_drift_lower hv hi hAC y) ha.le
    have hE := tensorDerivativeSquare_nonneg v y
    have hD := diffuseDefect_nonneg (smooth_C2 hv) hi hAC y
    have hP := (defectCarrier_bounds hv hi hAC y).1
    have hP0 : 0 ≤ defectCarrier v y := (div_nonneg hD (by norm_num)).trans hP
    have hDdiv : diffuseDefect v y / a ≤ 2 * defectCarrier v y := by
      apply (div_le_iff₀ ha).mpr
      nlinarith [mul_nonneg hP0 (sub_nonneg.mpr ha1)]
    have hEdiv : 0 ≤ tensorDerivativeSquare v y / a := div_nonneg hE ha.le
    have hscale := mul_le_mul_of_nonneg_left hDdiv hA.le
    have he : f = fun z => a⁻¹ * tensorDerivativeSquare v z := by
      funext z; dsimp [f]; rw [div_eq_mul_inv, mul_comm]
    rw [he, drift_const_mul (smooth_C2 (tensorDerivativeSquare_smooth hv hi))]
    dsimp only [f] at *
    simp only [div_eq_mul_inv] at hLow hscale hEdiv ⊢
    nlinarith
  have HH := quotient_bernstein_linear hf (smooth_C2 (defectCarrier_smooth hv hi)) (diffuseDrift v)
    (M := n ^ 3 * inverseJetConstant n ^ 2 / a)
    (B := 2 * Real.sqrt 2)
    (G := n * (inverseJetConstant n + a⁻¹ * (2 * n ^ 2 * inverseJetConstant n ^ 2)))
    (A := 2 * tensorSecondBernsteinConstant n) (c := c)
    (by positivity) (by positivity) (by positivity) (by positivity) hc
    (fun y => ⟨div_nonneg (tensorDerivativeSquare_nonneg v y) ha.le,
      div_le_div_of_nonneg_right (tensorDerivativeSquare_uniform hv hi hAC y) ha.le⟩)
    (fun y => ⟨(div_nonneg (diffuseDefect_nonneg (smooth_C2 hv) hi hAC y) (by norm_num)).trans
      (defectCarrier_bounds hv hi hAC y).1,
      (defectCarrier_bounds hv hi hAC y).2.trans (diffuseDefect_le_one v y)⟩)
    (diffuseDrift_bound (smooth_C2 hv) hi hAC) (defectCarrier_gradient_bound hv hi hAC)
    hfde (defectCarrier_drift_upper hv hi hAC) x
  have HH' := HH.trans (mul_le_mul_of_nonneg_left (defectCarrier_bounds hv hi hAC x).2 (by positivity))
  change tensorDerivativeSquare v x / a ≤ _ at HH'
  have Hfinal := (div_le_iff₀ ha).mp HH'
  dsimp only [derivativeDefectConstant]
  dsimp only [a,c] at Hfinal
  nlinarith

lemma coordDeriv_square {n : ℕ} {f : Space n → ℝ} (hf : Differentiable ℝ f)
    (i : Fin n) (x : Space n) : coordDeriv (fun y => f y ^ 2) i x = 2 * f x * coordDeriv f i x := by
  simp only [pow_two]
  rw [coordDeriv_mul hf hf]; ring

lemma coordDeriv_hessianSquare {n : ℕ} {v : Space n → ℝ}
    (hv : ContDiff ℝ ∞ v) (hi : ∀ x, v x ∈ Set.Ioo (-1 : ℝ) 1) (k : Fin n) (x : Space n) :
    coordDeriv (hessianSquare v) k x = ∑ i : Fin n, ∑ j : Fin n,
      2 * inverseHessian v i j x * coordDeriv (inverseHessian v i j) k x := by
  have hT (i j : Fin n) := (inverseHessian_smooth hv hi i j).differentiable (by simp)
  have he : hessianSquare v = fun y => ∑ i : Fin n, ∑ j : Fin n, inverseHessian v i j y ^ 2 :=
    funext (hessianSquare_eq_sum v)
  rw [he, coordDeriv_sum _ (fun i _ => Differentiable.fun_sum (fun j _ => (hT i j).fun_pow 2))]
  apply Finset.sum_congr rfl; intro i _
  rw [coordDeriv_sum _ (fun j _ => (hT i j).fun_pow 2)]
  apply Finset.sum_congr rfl; intro j _
  exact coordDeriv_square (hT i j) k x

lemma coordDeriv_hessianSquare_bound {n : ℕ} {v : Space n → ℝ}
    (hv : ContDiff ℝ ∞ v) (hi : ∀ x, v x ∈ Set.Ioo (-1 : ℝ) 1) (hAC : AllenCahn v)
    (k : Fin n) (x : Space n) : |coordDeriv (hessianSquare v) k x| ≤
      (tensorBernsteinConstant n + 3 + derivativeDefectConstant n) * diffuseDefect v x := by
  rw [coordDeriv_hessianSquare hv hi]
  have hh (i j : Fin n) : |2 * inverseHessian v i j x * coordDeriv (inverseHessian v i j) k x| ≤
      inverseHessian v i j x ^ 2 + ‖gradient (inverseHessian v i j) x‖ ^ 2 := by
    have hc := coordDeriv_abs_le_gradient (inverseHessian v i j) k x
    have hc2 := pow_le_pow_left₀ (abs_nonneg _) hc 2
    have hy := sq_nonneg (|inverseHessian v i j x| - |coordDeriv (inverseHessian v i j) k x|)
    simp only [sq_abs] at hc2 hy
    simp only [abs_mul, abs_of_nonneg (by norm_num : (0 : ℝ) ≤ 2)]
    nlinarith [sq_abs (inverseHessian v i j x), sq_abs (coordDeriv (inverseHessian v i j) k x)]
  calc |∑ i : Fin n, ∑ j : Fin n, 2 * inverseHessian v i j x * coordDeriv (inverseHessian v i j) k x| ≤
      ∑ i : Fin n, ∑ j : Fin n, |2 * inverseHessian v i j x * coordDeriv (inverseHessian v i j) k x| := by
        exact (Finset.abs_sum_le_sum_abs _ _).trans
          (Finset.sum_le_sum (fun i _ => Finset.abs_sum_le_sum_abs _ _))
    _ ≤ ∑ i : Fin n, ∑ j : Fin n, (inverseHessian v i j x ^ 2 + ‖gradient (inverseHessian v i j) x‖ ^ 2) :=
      Finset.sum_le_sum (fun i _ => Finset.sum_le_sum (fun j _ => hh i j))
    _ = hessianSquare v x + tensorDerivativeSquare v x := by
      simp only [Finset.sum_add_distrib, ← hessianSquare_eq_sum, tensorDerivativeSquare]
    _ ≤ _ := by linarith [hessianSquare_le_defect hv hi hAC x, tensorDerivativeSquare_le_defect hv hi hAC x]

def defectPotential {n : ℕ} (v : Space n → ℝ) (x : Space n) : ℝ :=
  2 * (defectWeight v x * (1 - diffuseDefect v x))

def defectSource {n : ℕ} (v : Space n → ℝ) (x : Space n) : ℝ :=
  defectPotential v x * diffuseDefect v x - 2 * hessianSquare v x

def defectPotentialConstant (n : ℕ) : ℝ := 8 * inverseJetConstant n * (1 + inverseJetConstant n)

def defectSourceConstant (n : ℕ) : ℝ := defectPotentialConstant n +
  2 * ((tensorBernsteinConstant n + 3 + derivativeDefectConstant n) + (tensorBernsteinConstant n + 3)) + 1

lemma defectPotentialConstant_nonneg (n : ℕ) : 0 ≤ defectPotentialConstant n := by
  have hJ := inverseJetConstant_one_le n
  dsimp [defectPotentialConstant]; positivity

lemma defectSourceConstant_pos (n : ℕ) : 0 < defectSourceConstant n := by
  have hP := defectPotentialConstant_nonneg n
  have hE := derivativeDefectConstant_pos n
  have hB : 0 ≤ tensorBernsteinConstant n := by dsimp [tensorBernsteinConstant]; positivity
  dsimp [defectSourceConstant]; positivity

lemma defectPotential_smooth {n : ℕ} {v : Space n → ℝ}
    (hv : ContDiff ℝ ∞ v) (hi : ∀ x, v x ∈ Set.Ioo (-1 : ℝ) 1) :
    ContDiff ℝ ∞ (defectPotential v) :=
  contDiff_const.mul ((contDiff_const.sub (hv.pow 2)).mul (contDiff_const.sub (diffuseDefect_smooth hv hi)))

lemma defectSource_smooth {n : ℕ} {v : Space n → ℝ}
    (hv : ContDiff ℝ ∞ v) (hi : ∀ x, v x ∈ Set.Ioo (-1 : ℝ) 1) :
    ContDiff ℝ ∞ (defectSource v) :=
  ((defectPotential_smooth hv hi).mul (diffuseDefect_smooth hv hi)).sub
    (contDiff_const.mul (hessianSquare_smooth hv hi))

lemma defectPotential_C1Bound {n : ℕ} {v : Space n → ℝ}
    (hv : ContDiff ℝ ∞ v) (hi : ∀ x, v x ∈ Set.Ioo (-1 : ℝ) 1) (hAC : AllenCahn v) :
    C1Bound (defectPotential v) (defectPotentialConstant n) := by
  have hJ : 0 ≤ inverseJetConstant n := (by norm_num : (0 : ℝ) ≤ 1).trans (inverseJetConstant_one_le n)
  have hq := (inverseJet_C1Bound hv hi hAC).2.1
  have hD := (inverseJet_C1Bound hv hi hAC).2.2.1
  have hdq : Differentiable ℝ (defectWeight v) := (contDiff_const.sub (hv.pow 2)).differentiable (by simp)
  have hdD := (diffuseDefect_smooth hv hi).differentiable (by simp)
  have hh := (C1Bound.const (n := n) 1).sub (differentiable_const 1) hdD hD
  simp only [abs_one] at hh
  have hprod := hq.mul hdq ((differentiable_const 1).sub hdD) (by positivity) (by positivity) hh
  have hm := hprod.const_mul (hdq.mul ((differentiable_const 1).sub hdD)) (by positivity) 2
  convert hm using 1
  · rfl
  · dsimp [defectPotentialConstant]; norm_num; ring

lemma diffuseDefect_drift_eq_source {n : ℕ} {v : Space n → ℝ}
    (hv : ContDiff ℝ ∞ v) (hi : ∀ x, v x ∈ Set.Ioo (-1 : ℝ) 1) (hAC : AllenCahn v) (x : Space n) :
    Laplacian.laplacian (diffuseDefect v) x - fderiv ℝ (diffuseDefect v) x (diffuseDrift v x) =
      defectSource v x := by
  rw [diffuseDefect_laplacian hv hi hAC]
  rw [diffuseDrift, map_smul, smul_eq_mul, ← inner_gradient_left, real_inner_comm]
  dsimp only [defectSource, defectPotential, diffuseDefect, hessianSquare]
  ring

lemma defectSource_bounds {n : ℕ} {v : Space n → ℝ}
    (hv : ContDiff ℝ ∞ v) (hi : ∀ x, v x ∈ Set.Ioo (-1 : ℝ) 1) (hAC : AllenCahn v) :
    (∀ x, |defectSource v x| ≤ defectSourceConstant n * diffuseDefect v x) ∧
    ∀ i x, |coordDeriv (defectSource v) i x| ≤ defectSourceConstant n *
      (diffuseDefect v x + |coordDeriv (diffuseDefect v) i x|) := by
  have hB : 0 ≤ tensorBernsteinConstant n := by dsimp [tensorBernsteinConstant]; positivity
  have hE := derivativeDefectConstant_pos n
  have hP := defectPotentialConstant_nonneg n
  have hc := defectPotential_C1Bound hv hi hAC
  have hdP := (defectPotential_smooth hv hi).differentiable (by simp)
  have hdD := (diffuseDefect_smooth hv hi).differentiable (by simp)
  have hdF := (hessianSquare_smooth hv hi).differentiable (by simp)
  constructor
  · intro x
    have hD := diffuseDefect_nonneg (smooth_C2 hv) hi hAC x
    have hF := hessianSquare_nonneg v x
    calc |defectSource v x| ≤ |defectPotential v x * diffuseDefect v x| + |2 * hessianSquare v x| := abs_sub _ _
      _ ≤ defectPotentialConstant n * diffuseDefect v x + 2 * hessianSquare v x := by
        simp only [abs_mul, abs_of_nonneg hD, abs_of_nonneg hF, abs_of_nonneg (by norm_num : (0 : ℝ) ≤ 2)]
        exact add_le_add (mul_le_mul_of_nonneg_right (hc.1 x) hD) le_rfl
      _ ≤ _ := by
        have hh := hessianSquare_le_defect hv hi hAC x
        have hp : 0 ≤ 2 * (tensorBernsteinConstant n + 3 + derivativeDefectConstant n) * diffuseDefect v x := by positivity
        dsimp [defectSourceConstant]; nlinarith
  · intro i x
    have hD := diffuseDefect_nonneg (smooth_C2 hv) hi hAC x
    have he : coordDeriv (defectSource v) i x =
        coordDeriv (fun y => defectPotential v y * diffuseDefect v y) i x -
          2 * coordDeriv (hessianSquare v) i x := by
      change fderiv ℝ (fun y => defectPotential v y * diffuseDefect v y - 2 * hessianSquare v y) x (basis n i) = _
      rw [fderiv_fun_sub ((hdP.fun_mul hdD) x) ((hdF.const_mul 2) x), sub_apply,
        fderiv_const_mul (hdF x)]
      rfl
    rw [he]
    apply ((abs_sub _ _).trans (add_le_add
      (coordDeriv_mul_estimate hdP hdD hP hc i x) (show |2 * coordDeriv (hessianSquare v) i x| ≤
        2 * ((tensorBernsteinConstant n + 3 + derivativeDefectConstant n) * diffuseDefect v x) by
          rw [abs_mul, abs_of_nonneg (by norm_num : (0 : ℝ) ≤ 2)]
          exact mul_le_mul_of_nonneg_left (coordDeriv_hessianSquare_bound hv hi hAC i x) (by norm_num)))).trans
    rw [abs_of_nonneg hD]
    have ht := abs_nonneg (coordDeriv (diffuseDefect v) i x)
    have hdiff : 0 ≤ (2 * (tensorBernsteinConstant n + 3) + 1) * diffuseDefect v x +
        (2 * ((tensorBernsteinConstant n + 3 + derivativeDefectConstant n) + (tensorBernsteinConstant n + 3)) + 1) *
          |coordDeriv (diffuseDefect v) i x| := by positivity
    dsimp [defectSourceConstant]; nlinarith

lemma drift_log_bochner {n : ℕ} {v h r : Space n → ℝ}
    (hv : ContDiff ℝ ∞ v) (hi : ∀ x, v x ∈ Set.Ioo (-1 : ℝ) 1)
    (hh : ContDiff ℝ ∞ h) (hr : ContDiff ℝ ∞ r)
    (heq : ∀ x, Laplacian.laplacian h x - fderiv ℝ h x (diffuseDrift v x) = r x - ‖gradient h x‖ ^ 2)
    (x : Space n) :
    Laplacian.laplacian (fun y => ‖gradient h y‖ ^ 2) x -
      fderiv ℝ (fun y => ‖gradient h y‖ ^ 2) x (diffuseDrift v x - (2 : ℝ) • gradient h x) =
    2 * (∑ i : Fin n, ‖gradient (coordDeriv h i) x‖ ^ 2) +
      2 * (∑ i : Fin n, coordDeriv h i x * coordDeriv r i x) +
      2 * (∑ i : Fin n, coordDeriv h i x * ∑ k : Fin n, coordDeriv (driftCoeff v k) i x * coordDeriv h k x) := by
  let w := fun y => ‖gradient h y‖ ^ 2
  have hw : ContDiff ℝ ∞ w := gradient_norm_sq_smooth hh
  have hd (i : Fin n) := smooth_C2 (coordDeriv_smooth hh i)
  have hL (i : Fin n) :
      Laplacian.laplacian (coordDeriv h i) x - fderiv ℝ (coordDeriv h i) x (diffuseDrift v x) =
      coordDeriv r i x - coordDeriv w i x +
        ∑ k : Fin n, coordDeriv (driftCoeff v k) i x * coordDeriv h k x := by
    rw [diffuse_drift_commute hv hi hh (hr.sub hw) heq]
    rw [coordDeriv_sub (hr.differentiable (by simp)) (hw.differentiable (by simp))]
  have he : w = fun y => ∑ i : Fin n, coordDeriv h i y ^ 2 := funext (gradient_norm_sq h)
  have hWL : Laplacian.laplacian w x - fderiv ℝ w x (diffuseDrift v x) =
      2 * (∑ i : Fin n, ‖gradient (coordDeriv h i) x‖ ^ 2) +
        2 * (∑ i : Fin n, coordDeriv h i x * coordDeriv r i x) -
        2 * (∑ i : Fin n, coordDeriv h i x * coordDeriv w i x) +
        2 * (∑ i : Fin n, coordDeriv h i x * ∑ k : Fin n, coordDeriv (driftCoeff v k) i x * coordDeriv h k x) := by
    conv_lhs => rw [he, drift_sum_identity _ (fun i _ => (hd i).pow 2)]
    simp_rw [drift_square_identity (hd _) (diffuseDrift v) x, hL]
    simp only [mul_add, mul_sub, Finset.sum_add_distrib, Finset.sum_sub_distrib, mul_assoc, ← Finset.mul_sum]
    ring
  have hg : fderiv ℝ w x (gradient h x) = ∑ i : Fin n, coordDeriv h i x * coordDeriv w i x := by
    rw [← inner_gradient_left, real_inner_comm, inner_gradient_eq_sum]
  change Laplacian.laplacian w x - fderiv ℝ w x (diffuseDrift v x - (2 : ℝ) • gradient h x) = _
  rw [map_sub, map_smul, smul_eq_mul, hg]
  linarith [hWL]

lemma laplacian_sq_le_hessian {n : ℕ} {f : Space n → ℝ} (hf : ContDiff ℝ ∞ f) (x : Space n) :
    Laplacian.laplacian f x ^ 2 ≤ n * ∑ i : Fin n, ‖gradient (coordDeriv f i) x‖ ^ 2 := by
  rw [laplacian_eq_sum_coordDeriv (smooth_C2 hf)]
  have hc := Finset.sum_mul_sq_le_sq_mul_sq (R := ℝ) Finset.univ
    (fun i : Fin n => coordDeriv (coordDeriv f i) i x) (fun _ : Fin n => (1 : ℝ))
  simp only [mul_one, one_pow, Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul] at hc
  apply hc.trans
  rw [mul_comm]
  apply mul_le_mul_of_nonneg_left _ (Nat.cast_nonneg n)
  apply Finset.sum_le_sum
  intro i _
  have hh := pow_le_pow_left₀ (abs_nonneg _) (coordDeriv_abs_le_gradient (coordDeriv f i) i x) 2
  simpa only [sq_abs] using hh

lemma log_bochner_lower {n : ℕ} {v h r : Space n → ℝ}
    (hv : ContDiff ℝ ∞ v) (hi : ∀ x, v x ∈ Set.Ioo (-1 : ℝ) 1)
    (hh : ContDiff ℝ ∞ h) (hr : ContDiff ℝ ∞ r) {R C : ℝ} (hR : 0 ≤ R) (hC : 0 ≤ C)
    (heq : ∀ x, Laplacian.laplacian h x - fderiv ℝ h x (diffuseDrift v x) = r x - ‖gradient h x‖ ^ 2)
    (hrb : ∀ i x, |coordDeriv r i x| ≤ R * (1 + |coordDeriv h i x|))
    (hcb : ∀ i k x, |coordDeriv (driftCoeff v k) i x| ≤ C) (x : Space n) :
    2 * (∑ i : Fin n, ‖gradient (coordDeriv h i) x‖ ^ 2) -
      R * n - (3 * R + 2 * C * n) * ‖gradient h x‖ ^ 2 ≤
    Laplacian.laplacian (fun y => ‖gradient h y‖ ^ 2) x -
      fderiv ℝ (fun y => ‖gradient h y‖ ^ 2) x (diffuseDrift v x - (2 : ℝ) • gradient h x) := by
  have hp (i : Fin n) : -(R * (1 + 3 * coordDeriv h i x ^ 2)) ≤
      2 * coordDeriv h i x * coordDeriv r i x := by
    have hm := mul_le_mul_of_nonneg_left (hrb i x) (show 0 ≤ 2 * |coordDeriv h i x| by positivity)
    have hlow : -(2 * |coordDeriv h i x| * |coordDeriv r i x|) ≤ 2 * coordDeriv h i x * coordDeriv r i x := by
      have ht := neg_abs_le (2 * coordDeriv h i x * coordDeriv r i x)
      simpa only [abs_mul, abs_of_nonneg (by norm_num : (0 : ℝ) ≤ 2)] using ht
    have hs := mul_nonneg hR (sq_nonneg (|coordDeriv h i x| - 1))
    nlinarith [sq_abs (coordDeriv h i x)]
  have hd (i k : Fin n) : -(C * (coordDeriv h i x ^ 2 + coordDeriv h k x ^ 2)) ≤
      2 * coordDeriv h i x * (coordDeriv (driftCoeff v k) i x * coordDeriv h k x) := by
    have hm := mul_le_mul_of_nonneg_left (hcb i k x)
      (show 0 ≤ 2 * |coordDeriv h i x| * |coordDeriv h k x| by positivity)
    have hlow := neg_abs_le (2 * coordDeriv h i x * (coordDeriv (driftCoeff v k) i x * coordDeriv h k x))
    simp only [abs_mul, abs_of_nonneg (by norm_num : (0 : ℝ) ≤ 2)] at hlow
    have hs := mul_nonneg hC (sq_nonneg (|coordDeriv h i x| - |coordDeriv h k x|))
    nlinarith [sq_abs (coordDeriv h i x), sq_abs (coordDeriv h k x)]
  have HP := Finset.sum_le_sum (fun (i : Fin n) (_ : i ∈ Finset.univ) => hp i)
  have HD := Finset.sum_le_sum (fun (i : Fin n) (_ : i ∈ Finset.univ) =>
    Finset.sum_le_sum (fun (k : Fin n) (_ : k ∈ Finset.univ) => hd i k))
  simp only [Finset.sum_neg_distrib, Finset.sum_add_distrib, Finset.sum_const,
    Finset.card_univ, Fintype.card_fin, nsmul_eq_mul, ← Finset.mul_sum, ← mul_assoc,
    ← gradient_norm_sq] at HP HD
  simp only [mul_assoc, ← Finset.mul_sum] at HP HD
  rw [drift_log_bochner hv hi hh hr heq]
  nlinarith

lemma bounded_drift_logistic_scaled {n : ℕ} {f : Space n → ℝ}
    (hf : ContDiff ℝ 2 f) (b : Space n → Space n) {M B A N : ℝ}
    (hM : 0 ≤ M) (hB : 0 ≤ B) (hA : 0 ≤ A) (hN : 0 < N)
    (hfb : ∀ x, |f x| ≤ M) (hbb : ∀ x, ‖b x‖ ≤ B)
    (hpde : ∀ x, f x ^ 2 - A * N * f x - A * N ^ 2 ≤
      N * (Laplacian.laplacian f x - fderiv ℝ f x (b x))) :
    ∀ x, f x ≤ N * (A + 1) := by
  let g := fun x => f x / N
  have hg : ContDiff ℝ 2 g := hf.div_const N
  have hgb (x : Space n) : |g x| ≤ M / N := by
    dsimp [g]; rw [abs_div, abs_of_pos hN]; exact div_le_div_of_nonneg_right (hfb x) hN.le
  have hLg (x : Space n) : Laplacian.laplacian g x - fderiv ℝ g x (b x) =
      (Laplacian.laplacian f x - fderiv ℝ f x (b x)) / N := by
    have he : g = fun y => N⁻¹ * f y := by funext y; dsimp [g]; rw [div_eq_mul_inv, mul_comm]
    rw [he, drift_const_mul hf]
    simp only [div_eq_mul_inv, mul_comm]
  have hl (x : Space n) : g x ^ 2 - A * g x - A ≤
      Laplacian.laplacian g x - fderiv ℝ g x (b x) := by
    rw [hLg]
    apply (le_div_iff₀ hN).mpr
    apply (mul_le_mul_iff_right₀ hN).mp
    have he : N * ((g x ^ 2 - A * g x - A) * N) = f x ^ 2 - A * N * f x - A * N ^ 2 := by
      dsimp [g]; field_simp
    rw [he]
    exact hpde x
  have HH := bounded_drift_logistic hg b (div_nonneg hM hN.le) hB hA hgb hbb hl
  intro x
  have hh := (div_le_iff₀ hN).mp (HH x)
  simpa only [mul_comm] using hh

end DeGiorgi
end

end OAI