lean/OAI/Analysis/AllenCahn/HessianControl.lean

import OAI.Analysis.AllenCahn.Barriers

namespace OAI

noncomputable section
namespace DeGiorgi
open scoped ContDiff
open Filter Topology

lemma diffuseDefect_barrier_lower {n : ℕ} {v : Space n → ℝ}
    (hv : ContDiff ℝ ∞ v) (hi : ∀ x, v x ∈ Set.Ioo (-1 : ℝ) 1) (hAC : AllenCahn v)
    (hp : ∀ x, 0 < diffuseDefect v x) {κ : ℝ} (hκ : 2 * Real.sqrt 2 < κ)
    (y x : Space n) :
    (diffuseDefect v y * Real.exp (-relativeDefectConstant n * sharpDefectRadius n κ)) *
      radialBarrier κ x ≤ diffuseDefect v (y + x) := by
  let R := sharpDefectRadius n κ
  let C := relativeDefectConstant n
  let A := diffuseDefect v y * Real.exp (-C * R)
  let f := fun z : Space n => A * radialBarrier κ z
  let g := fun z : Space n => diffuseDefect v (y + z)
  have hAp : 0 < A := mul_pos (hp y) (Real.exp_pos _)
  have hk : 0 < κ := lt_trans (by positivity) hκ
  have hC : 0 < C := relativeDefectConstant_pos n
  have hs := diffuseDefect_smooth hv hi
  have hbs := smooth_C2 (radialBarrier_smooth n κ)
  have hfs : ContDiff ℝ 2 f := contDiff_const.mul hbs
  have hgs : ContDiff ℝ 2 g := (smooth_C2 hs).comp (contDiff_const.add contDiff_id)
  have hgder (z : Space n) : fderiv ℝ g z = fderiv ℝ (diffuseDefect v) (y + z) := by
    have H := (hs.differentiable (by simp) (y+z)).hasFDerivAt.comp z
      ((hasFDerivAt_const y z).add (hasFDerivAt_id z))
    simpa only [g, Function.comp_def, zero_add, ContinuousLinearMap.comp_id] using H.fderiv
  have hglap (z : Space n) : Laplacian.laplacian g z = Laplacian.laplacian (diffuseDefect v) (y + z) :=
    laplacian_translate (smooth_C2 hs) y z
  have hg0 (z : Space n) : 0 ≤ g z := (hp (y+z)).le
  have hdecay : Tendsto f (Bornology.cobounded (Space n)) (𝓝 0) := by
    have H := (radialBarrier_decay (n := n) hk).const_mul A
    simpa only [mul_zero] using H
  have hinner (z : Space n) (hz : ‖z‖ ≤ R) : f z ≤ g z := by
    have H := diffuseDefect_exp_comparison_crude hv hi hAC hp (y+z) y
    have he : y - (y + z) = -z := by abel
    rw [he, norm_neg] at H
    have hex : Real.exp (C * ‖z‖) ≤ Real.exp (C * R) :=
      Real.exp_le_exp.mpr (mul_le_mul_of_nonneg_left hz hC.le)
    have HH : diffuseDefect v y ≤ Real.exp (C * R) * g z :=
      H.trans (mul_le_mul_of_nonneg_right hex (hg0 z))
    have HA : A ≤ g z := by
      have He := mul_le_mul_of_nonneg_left HH (Real.exp_pos (-C*R)).le
      have Hexp : Real.exp (-C*R) * Real.exp (C*R) = 1 := by
        rw [← Real.exp_add]
        have hh : -C * R + C * R = 0 := by ring
        rw [hh, Real.exp_zero]
      dsimp [A]
      nlinarith [He, Hexp]
    have hb1 : radialBarrier κ z ≤ 1 := by
      change Real.exp (-κ * smoothRadius z) ≤ 1
      exact Real.exp_le_one_iff.mpr (by nlinarith [smoothRadius_pos z])
    exact (mul_le_of_le_one_right hAp.le hb1).trans HA
  have hsub (z : Space n) (hz : R < ‖z‖) :
      -Laplacian.laplacian f z + fderiv ℝ f z (diffuseDrift v (y+z)) +
        defectPotential v (y+z) * f z < 0 := by
    have H := mul_neg_of_pos_of_neg hAp (radialBarrier_defect_subsolution (smooth_C2 hv) hi hAC hκ y z hz)
    dsimp only [f]
    rw [laplacian_fun_const_mul hbs, fderiv_const_mul (hbs.differentiable (by norm_num) z),
      smul_apply, smul_eq_mul]
    nlinarith
  have hsuper (z : Space n) : 0 ≤ -Laplacian.laplacian g z +
      fderiv ℝ g z (diffuseDrift v (y+z)) + defectPotential v (y+z) * g z := by
    rw [hglap, hgder]
    have H := diffuseDefect_drift_eq_source hv hi hAC (y+z)
    have H0 : 0 ≤ hessianSquare v (y+z) := by dsimp [hessianSquare]; positivity
    dsimp only [defectSource] at H
    change 0 ≤ -Laplacian.laplacian (diffuseDefect v) (y+z) +
      fderiv ℝ (diffuseDefect v) (y+z) (diffuseDrift v (y+z)) +
      defectPotential v (y+z) * diffuseDefect v (y+z)
    linarith
  exact exterior_comparison hfs hgs (fun z => diffuseDrift v (y+z))
    (fun z => defectPotential v (y+z)) R (fun z => defectPotential_nonneg hi (y+z))
    hg0 hdecay hinner hsub hsuper x

def sharpDefectConstant (n : ℕ) (γ : ℝ) : ℝ :=
  Real.exp (relativeDefectConstant n * sharpDefectRadius n (2 * Real.sqrt 2 + γ) +
    (2 * Real.sqrt 2 + γ))

theorem diffuseDefect_exponential_comparison {n : ℕ} {v : Space n → ℝ}
    (hv : ContDiff ℝ ∞ v) (hi : ∀ x, v x ∈ Set.Ioo (-1 : ℝ) 1) (hAC : AllenCahn v)
    (hp : ∀ x, 0 < diffuseDefect v x) {γ : ℝ} (hγ : 0 < γ) (y z : Space n) :
    diffuseDefect v y ≤ sharpDefectConstant n γ *
      Real.exp ((2 * Real.sqrt 2 + γ) * ‖y - z‖) * diffuseDefect v z := by
  let κ := 2 * Real.sqrt 2 + γ
  let C := relativeDefectConstant n
  let R := sharpDefectRadius n κ
  have hκ : 2 * Real.sqrt 2 < κ := by dsimp [κ]; linarith
  have hk : 0 < κ := lt_trans (by positivity) hκ
  have H := diffuseDefect_barrier_lower hv hi hAC hp hκ y (z-y)
  have he : y + (z-y) = z := by abel
  rw [he] at H
  have Hexp : Real.exp (C * R + κ * smoothRadius (z-y)) *
      (Real.exp (-C * R) * radialBarrier κ (z-y)) = 1 := by
    dsimp [radialBarrier]
    rw [← Real.exp_add, ← Real.exp_add]
    have hh : C * R + κ * smoothRadius (z-y) + (-C*R + -κ*smoothRadius (z-y)) = 0 := by ring
    rw [hh, Real.exp_zero]
  have Hmul := mul_le_mul_of_nonneg_left H (Real.exp_pos (C * R + κ * smoothRadius (z-y))).le
  have H1 : diffuseDefect v y ≤ Real.exp (C * R + κ * smoothRadius (z-y)) * diffuseDefect v z := by
    calc diffuseDefect v y = diffuseDefect v y * 1 := (mul_one _).symm
      _ = diffuseDefect v y * (Real.exp (C * R + κ * smoothRadius (z-y)) *
          (Real.exp (-C * R) * radialBarrier κ (z-y))) := by rw [Hexp]
      _ = Real.exp (C * R + κ * smoothRadius (z-y)) *
          (diffuseDefect v y * Real.exp (-C * R) * radialBarrier κ (z-y)) := by ring
      _ ≤ _ := Hmul
  have H2 : Real.exp (C * R + κ * smoothRadius (z-y)) ≤
      Real.exp (C * R + κ) * Real.exp (κ * ‖y-z‖) := by
    rw [← Real.exp_add]
    apply Real.exp_le_exp.mpr
    have HH := mul_le_mul_of_nonneg_left (smoothRadius_le_norm_add_one (z-y)) hk.le
    rw [norm_sub_rev z y] at HH
    linarith
  exact H1.trans (mul_le_mul_of_nonneg_right H2 (hp z).le)

end DeGiorgi
end

noncomputable section
namespace DeGiorgi
open scoped ContDiff

lemma positive_defect_log_bounds {n : ℕ} {v : Space n → ℝ}
    (hv : ContDiff ℝ ∞ v) (hi : ∀ x, v x ∈ Set.Ioo (-1 : ℝ) 1) (hAC : AllenCahn v)
    (hp : ∀ x, 0 < diffuseDefect v x) :
    let h := fun y => Real.log (diffuseDefect v y)
    let r := fun y => defectSource v y / diffuseDefect v y
    (∀ x, Laplacian.laplacian h x - fderiv ℝ h x (diffuseDrift v x) = r x - ‖gradient h x‖ ^ 2) ∧
    (∀ x, ‖gradient h x‖ ≤ relativeDefectConstant n) ∧
    (∀ i x, |coordDeriv r i x| ≤ 2 * defectSourceConstant n * (1 + relativeDefectConstant n)) := by
  dsimp only
  let D := diffuseDefect v
  let h := fun y => Real.log (D y)
  let r := fun y => defectSource v y / D y
  have hs := diffuseDefect_smooth hv hi
  have hd := hs.differentiable (by simp)
  have hne (x) : D x ≠ 0 := ne_of_gt (hp x)
  have hgb (x) : ‖gradient h x‖ ≤ relativeDefectConstant n := by
    dsimp only [h]
    rw [gradient_log (hd x) (hne x), norm_smul, Real.norm_eq_abs, abs_inv, abs_of_pos (hp x),
      inv_mul_eq_div]
    exact (div_le_iff₀ (hp x)).mpr (diffuseDefect_relative_gradient_bound hv hi hAC x)
  have hhi (i : Fin n) (x) : coordDeriv h i x = coordDeriv D i x / D x :=
    coordDeriv_log hd hne i x
  have hS := defectSourceConstant_pos n
  have hC := relativeDefectConstant_pos n
  have hc := defectSource_bounds hv hi hAC
  have hrb (x) : |r x| ≤ defectSourceConstant n := by
    dsimp [r]
    rw [abs_div, abs_of_pos (hp x)]
    exact (div_le_iff₀ (hp x)).mpr (hc.1 x)
  constructor
  · intro x
    rw [drift_log (smooth_C2 hs) hne, diffuseDefect_drift_eq_source hv hi hAC]
  constructor
  · exact hgb
  · intro i x
    change |coordDeriv r i x| ≤ _
    have hri : coordDeriv r i x = coordDeriv (defectSource v) i x / D x - r x * coordDeriv h i x := by
      dsimp only [r]
      rw [coordDeriv_div ((defectSource_smooth hv hi).differentiable (by simp)) hd hne, hhi]
      dsimp only [D]
      field_simp [ne_of_gt (hp x)]
    have hic : |coordDeriv h i x| ≤ relativeDefectConstant n :=
      (coordDeriv_abs_le_gradient h i x).trans (hgb x)
    have hsr : |coordDeriv (defectSource v) i x| / D x ≤
        defectSourceConstant n * (1 + relativeDefectConstant n) := by
      apply (div_le_iff₀ (hp x)).mpr
      have hg := (coordDeriv_abs_le_gradient D i x).trans
        (diffuseDefect_relative_gradient_bound hv hi hAC x)
      have hh := hc.2 i x
      dsimp only [D] at hg ⊢
      nlinarith
    rw [hri]
    apply (abs_sub _ _).trans
    rw [abs_div, abs_of_pos (hp x), abs_mul]
    have hm := mul_le_mul (hrb x) hic (abs_nonneg _) hS.le
    nlinarith

lemma drift_log_coordinate {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)
    (i : Fin n) (x : Space n) :
    Laplacian.laplacian (coordDeriv h i) x -
      fderiv ℝ (coordDeriv h i) x (diffuseDrift v x - (2 : ℝ) • gradient h x) =
      coordDeriv r i x + ∑ k : Fin n, coordDeriv (driftCoeff v k) i x * coordDeriv h k x := by
  have hw := gradient_norm_sq_smooth hh
  have H := diffuse_drift_commute hv hi hh (hr.sub hw) heq i x
  rw [coordDeriv_sub (hr.differentiable (by simp)) (hw.differentiable (by simp))] at H
  have hd : coordDeriv (fun y => ‖gradient h y‖ ^ 2) i x =
      2 * fderiv ℝ (coordDeriv h i) x (gradient h x) := by
    have he : (fun y => ‖gradient h y‖ ^ 2) = fun y => ∑ j : Fin n, coordDeriv h j y ^ 2 :=
      funext (gradient_norm_sq h)
    have hds (j : Fin n) := (coordDeriv_smooth hh j).differentiable (by simp)
    rw [he, coordDeriv_sum (f := fun j y => coordDeriv h j y ^ 2) _ (fun j _ => (hds j).pow 2)]
    rw [← inner_gradient_left, inner_gradient_eq_sum, Finset.mul_sum]
    apply Finset.sum_congr rfl
    intro j _
    have hs : coordDeriv (fun y => coordDeriv h j y ^ 2) i x =
        2 * coordDeriv h j x * coordDeriv (coordDeriv h j) i x := by
      change fderiv ℝ (fun y => coordDeriv h j y ^ 2) x (basis n i) = _
      rw [fderiv_fun_pow 2 (hds j x)]
      simp [coordDeriv, mul_assoc]
    rw [hs, coordDeriv_comm (smooth_C2 hh) j i]
    ring
  rw [hd] at H
  rw [map_sub, map_smul, smul_eq_mul]
  linarith

def logDefectHessianConstant (n : ℕ) : ℝ :=
  2 * (2 * relativeDefectConstant n +
    (2 * defectSourceConstant n * (1 + relativeDefectConstant n) +
      n * (tensorCoeffConstant n * relativeDefectConstant n)) + 3) *
        (2 * Real.sqrt 2 + 2 * relativeDefectConstant n + 1)

lemma logDefectHessianConstant_pos (n : ℕ) : 0 < logDefectHessianConstant n := by
  have hC := relativeDefectConstant_pos n
  have hS := defectSourceConstant_pos n
  have hT := tensorCoeffConstant_pos n
  dsimp [logDefectHessianConstant]; positivity

lemma logDefect_hessian_bound {n : ℕ} {v : Space n → ℝ}
    (hv : ContDiff ℝ ∞ v) (hi : ∀ x, v x ∈ Set.Ioo (-1 : ℝ) 1) (hAC : AllenCahn v)
    (hp : ∀ x, 0 < diffuseDefect v x) (i : Fin n) (x : Space n) :
    ‖gradient (coordDeriv (fun y => Real.log (diffuseDefect v y)) i) x‖ ≤ logDefectHessianConstant n := by
  let h := fun y => Real.log (diffuseDefect v y)
  let r := fun y => defectSource v y / diffuseDefect v y
  let C := relativeDefectConstant n
  let S := 2 * defectSourceConstant n * (1 + C) + n * (tensorCoeffConstant n * C)
  let B := 2 * Real.sqrt 2 + 2 * C
  have hC : 0 ≤ C := (relativeDefectConstant_pos n).le
  have hS : 0 ≤ S := by have := (defectSourceConstant_pos n).le; have := (tensorCoeffConstant_pos n).le; dsimp [S]; positivity
  have hB : 0 ≤ B := by dsimp [B]; positivity
  have hne (y) : diffuseDefect v y ≠ 0 := ne_of_gt (hp y)
  have hh : ContDiff ℝ ∞ h := (diffuseDefect_smooth hv hi).log hne
  have hr : ContDiff ℝ ∞ r := (defectSource_smooth hv hi).div (diffuseDefect_smooth hv hi) hne
  obtain ⟨heq,hgb,hrb⟩ := positive_defect_log_bounds hv hi hAC hp
  have hcb (k : Fin n) (y) : |coordDeriv h k y| ≤ C :=
    (coordDeriv_abs_le_gradient h k y).trans (hgb y)
  have hdb (y) : ‖diffuseDrift v y - (2 : ℝ) • gradient h y‖ ≤ B := by
    apply (norm_sub_le _ _).trans
    rw [norm_smul, Real.norm_eq_abs, abs_of_pos (by norm_num : (0 : ℝ) < 2)]
    exact add_le_add (diffuseDrift_bound (smooth_C2 hv) hi hAC y) (mul_le_mul_of_nonneg_left (hgb y) (by norm_num))
  have hpb (y) : |Laplacian.laplacian (coordDeriv h i) y -
      fderiv ℝ (coordDeriv h i) y (diffuseDrift v y - (2 : ℝ) • gradient h y)| ≤ S := by
    rw [drift_log_coordinate hv hi hh hr heq i y]
    apply (abs_add_le _ _).trans (add_le_add (hrb i y) _)
    apply (Finset.abs_sum_le_sum_abs _ _).trans
    calc (∑ k : Fin n, |coordDeriv (driftCoeff v k) i y * coordDeriv h k y|) ≤
        ∑ k : Fin n, tensorCoeffConstant n * C := by
          apply Finset.sum_le_sum
          intro k _
          rw [abs_mul]
          exact mul_le_mul ((tensorCoeff_C1Bound hv hi hAC).2.2.2.2 k |>.2 i y)
            (hcb k y) (abs_nonneg _) (tensorCoeffConstant_pos n).le
      _ = n * (tensorCoeffConstant n * C) := by simp
  exact PoissonSupport.DeGiorgi.bounded_drift_gradient (smooth_C2 (coordDeriv_smooth hh i))
    (fun y => diffuseDrift v y - (2 : ℝ) • gradient h y) hC hS hB (hcb i) hdb hpb x

def relativeHessianConstant (n : ℕ) : ℝ :=
  n * (relativeDefectConstant n ^ 2 + logDefectHessianConstant n)

theorem diffuseDefect_relative_hessian_bound {n : ℕ} {v : Space n → ℝ}
    (hv : ContDiff ℝ ∞ v) (hi : ∀ x, v x ∈ Set.Ioo (-1 : ℝ) 1) (hAC : AllenCahn v)
    (hp : ∀ x, 0 < diffuseDefect v x) (i : Fin n) (x : Space n) :
    ‖gradient (coordDeriv (diffuseDefect v) i) x‖ ≤ relativeHessianConstant n * diffuseDefect v x := by
  let D := diffuseDefect v
  let h := fun y => Real.log (D y)
  have hne (y) : D y ≠ 0 := ne_of_gt (hp y)
  have hs := diffuseDefect_smooth hv hi
  have hd := hs.differentiable (by simp)
  have hh : ContDiff ℝ ∞ h := hs.log hne
  have hhd (i : Fin n) := (coordDeriv_smooth hh i).differentiable (by simp)
  have hgb := (positive_defect_log_bounds hv hi hAC hp).2.1
  have hic (j : Fin n) : |coordDeriv h j x| ≤ relativeDefectConstant n :=
    (coordDeriv_abs_le_gradient h j x).trans (hgb x)
  have he (j : Fin n) : coordDeriv D j = fun y => D y * coordDeriv h j y := by
    funext y
    rw [show coordDeriv h j y = coordDeriv D j y / D y from coordDeriv_log hd hne j y]
    field_simp [hne y]
  have hc (j : Fin n) : |coordDeriv (coordDeriv D i) j x| ≤
      (relativeDefectConstant n ^ 2 + logDefectHessianConstant n) * D x := by
    rw [he i, coordDeriv_mul hd (hhd i)]
    have hDi := (coordDeriv_abs_le_gradient D j x).trans
      (diffuseDefect_relative_gradient_bound hv hi hAC x)
    have hH := (coordDeriv_abs_le_gradient (coordDeriv h i) j x).trans
      (logDefect_hessian_bound hv hi hAC hp i x)
    have hm₁ := mul_le_mul hDi (hic i) (abs_nonneg _) (mul_nonneg (relativeDefectConstant_pos n).le (hp x).le)
    have hm₂ := mul_le_mul_of_nonneg_left hH (hp x).le
    apply (abs_add_le _ _).trans
    rw [abs_mul, abs_mul, abs_of_pos (hp x)]
    nlinarith
  apply (gradient_norm_le_sum_abs _ x).trans
  calc (∑ j : Fin n, |coordDeriv (coordDeriv D i) j x|) ≤
      ∑ j : Fin n, (relativeDefectConstant n ^ 2 + logDefectHessianConstant n) * D x :=
      Finset.sum_le_sum fun j _ => hc j
    _ = relativeHessianConstant n * D x := by simp [relativeHessianConstant]; ring

lemma carrier_gradient_estimate {n : ℕ} {f d : Space n → ℝ}
    (hf : ContDiff ℝ 2 f) (hd : ContDiff ℝ 2 d) (hp : ∀ x, 0 < d x)
    (b : Space n → Space n) {M C B G V : ℝ}
    (hM : 0 ≤ M) (hC : 0 ≤ C) (hB : 0 ≤ B) (hG : 0 ≤ G) (hV : 0 ≤ V)
    (hfb : ∀ x, |f x| ≤ M * d x) (hbb : ∀ x, ‖b x‖ ≤ B)
    (hgb : ∀ x, ‖gradient d x‖ ≤ G * d x)
    (hfL : ∀ x, |Laplacian.laplacian f x - fderiv ℝ f x (b x)| ≤ C * d x)
    (hdL : ∀ x, |Laplacian.laplacian d x - fderiv ℝ d x (b x)| ≤ V * d x)
    (x : Space n) :
    ‖gradient f x‖ ≤
      (2 * (2 * M + (C + M * V) + 3) * (B + 2 * G + 1) + M * G) * d x := by
  let w := fun y => f y / d y
  let b' := fun y => b y - (2 / d y) • gradient d y
  have hne y : d y ≠ 0 := ne_of_gt (hp y)
  have hw : ContDiff ℝ 2 w := hf.div hd hne
  have hwb (y) : |w y| ≤ M := by
    dsimp [w]; rw [abs_div, abs_of_pos (hp y)]
    exact (div_le_iff₀ (hp y)).mpr (hfb y)
  have hb' (y) : ‖b' y‖ ≤ B + 2 * G := by
    apply (norm_sub_le _ _).trans
    rw [norm_smul, Real.norm_eq_abs, abs_of_pos (div_pos (by norm_num) (hp y))]
    apply add_le_add (hbb y)
    calc (2 / d y) * ‖gradient d y‖ ≤ (2 / d y) * (G * d y) :=
        mul_le_mul_of_nonneg_left (hgb y) (div_nonneg (by norm_num) (hp y).le)
      _ = 2 * G := by field_simp [hne y]
  have hwL (y) : |Laplacian.laplacian w y - fderiv ℝ w y (b' y)| ≤ C + M * V := by
    have H := drift_quotient_identity hf hd hne b y
    change d y * (Laplacian.laplacian w y - fderiv ℝ w y (b' y)) = _ at H
    have Habs := congrArg abs H
    rw [abs_mul, abs_of_pos (hp y)] at Habs
    have hm := mul_le_mul (hwb y) (hdL y) (abs_nonneg _) hM
    have hm' : |w y * (Laplacian.laplacian d y - fderiv ℝ d y (b y))| ≤ M * (V * d y) := by
      rw [abs_mul]; exact hm
    have hh := (abs_sub (Laplacian.laplacian f y - fderiv ℝ f y (b y))
      (w y * (Laplacian.laplacian d y - fderiv ℝ d y (b y)))).trans (add_le_add (hfL y) hm')
    rw [← Habs] at hh
    nlinarith [hp y]
  have hgw := PoissonSupport.DeGiorgi.bounded_drift_gradient hw b' hM
    (add_nonneg hC (mul_nonneg hM hV)) (add_nonneg hB (mul_nonneg (by norm_num) hG))
    hwb hb' hwL x
  have he : f = fun y => w y * d y := by
    funext y; dsimp [w]; field_simp [hne y]
  have hg : gradient f x = w x • gradient d x + d x • gradient w x := by
    rw [he]
    simp only [gradient, fderiv_fun_mul (hw.differentiable (by norm_num) x) (hd.differentiable (by norm_num) x), map_add, map_smul]
  rw [hg]
  apply (norm_add_le _ _).trans
  rw [norm_smul, norm_smul, Real.norm_eq_abs, Real.norm_eq_abs, abs_of_pos (hp x)]
  have hm₁ := mul_le_mul (hwb x) (hgb x) (norm_nonneg _) hM
  have hm₂ := mul_le_mul_of_nonneg_left hgw (hp x).le
  nlinarith

end DeGiorgi
end

end OAI