lean/OAI/Analysis/AllenCahn/TensorBounds.lean

import OAI.Analysis.AllenCahn.TensorCalculus

namespace OAI

noncomputable section
namespace DeGiorgi
open scoped ContDiff
open Filter Topology

lemma hessianSquare_drift_identity {n : ℕ} {v : Space n → ℝ}
    (hv : ContDiff ℝ ∞ v) (hi : ∀ x, v x ∈ Set.Ioo (-1 : ℝ) 1)
    (x : Space n) :
    Laplacian.laplacian (hessianSquare v) x - fderiv ℝ (hessianSquare v) x (diffuseDrift v x) =
      ∑ i : Fin n, ∑ j : Fin n, (2 * ‖gradient (inverseHessian v i j) x‖ ^ 2 +
        2 * inverseHessian v i j x * (Laplacian.laplacian (inverseHessian v i j) x -
          fderiv ℝ (inverseHessian v i j) x (diffuseDrift v x))) := by
  have hT (i j : Fin n) : ContDiff ℝ 2 (inverseHessian v i j) :=
    smooth_C2 (inverseHessian_smooth hv hi i j)
  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, laplacian_sum _ (fun i _ => ContDiff.sum (fun j _ => (hT i j).pow 2))]
  rw [fderiv_fun_sum (A := fun i y => ∑ j : Fin n, inverseHessian v i j y ^ 2)
    (fun i _ => DifferentiableAt.fun_sum
    (fun j _ => ((hT i j).differentiable (by norm_num) x).fun_pow 2))]
  simp only [sum_apply, ← Finset.sum_sub_distrib]
  apply Finset.sum_congr rfl
  intro i _
  rw [laplacian_sum _ (fun j _ => (hT i j).pow 2),
    fderiv_fun_sum (A := fun j y => inverseHessian v i j y ^ 2)
      (fun j _ => ((hT i j).differentiable (by norm_num) x).fun_pow 2)]
  simp only [sum_apply, ← Finset.sum_sub_distrib]
  apply Finset.sum_congr rfl
  intro j _
  exact drift_square_identity (hT i j) (diffuseDrift v) x

def tensorSystemConstant (n : ℕ) : ℝ :=
  2 + 4 * n + 4 * n * (12 * (2 * Real.sqrt 2 + 1))

def tensorBernsteinConstant (n : ℕ) : ℝ := 1 + 2 * n ^ 2 * tensorSystemConstant n ^ 2

lemma hessianSquare_drift_lower {n : ℕ} {v : Space n → ℝ}
    (hv : ContDiff ℝ ∞ v) (hi : ∀ x, v x ∈ Set.Ioo (-1 : ℝ) 1) (hAC : AllenCahn v)
    (x : Space n) :
    -tensorBernsteinConstant n * (hessianSquare v x + diffuseDefect v x ^ 2) ≤
      Laplacian.laplacian (hessianSquare v) x - fderiv ℝ (hessianSquare v) x (diffuseDrift v x) := by
  let C := tensorSystemConstant n
  let S := Real.sqrt (hessianSquare v x)
  have hC : 0 ≤ C := by dsimp [C, tensorSystemConstant]; positivity
  have hS : 0 ≤ S := Real.sqrt_nonneg _
  have hSsq : S ^ 2 = hessianSquare v x := Real.sq_sqrt (hessianSquare_nonneg v x)
  have hD : 0 ≤ diffuseDefect v x := diffuseDefect_nonneg (smooth_C2 hv) hi hAC x
  have hpair (i j : Fin n) :
      -(inverseHessian v i j x ^ 2) - 2 * C ^ 2 * (hessianSquare v x + diffuseDefect v x ^ 2) ≤
        2 * ‖gradient (inverseHessian v i j) x‖ ^ 2 +
        2 * inverseHessian v i j x * (Laplacian.laplacian (inverseHessian v i j) x -
          fderiv ℝ (inverseHessian v i j) x (diffuseDrift v x)) := by
    let R := Laplacian.laplacian (inverseHessian v i j) x - fderiv ℝ (inverseHessian v i j) x (diffuseDrift v x)
    have hR : |R| ≤ C * (diffuseDefect v x + S) := inverseHessian_drift_abs_bound hv hi hAC i j x
    have hR2 : R ^ 2 ≤ 2 * C ^ 2 * (hessianSquare v x + diffuseDefect v x ^ 2) := by
      calc R ^ 2 = |R| ^ 2 := (sq_abs R).symm
        _ ≤ (C * (diffuseDefect v x + S)) ^ 2 := pow_le_pow_left₀ (abs_nonneg R) hR 2
        _ = C ^ 2 * (diffuseDefect v x + S) ^ 2 := by ring
        _ ≤ C ^ 2 * (2 * (hessianSquare v x + diffuseDefect v x ^ 2)) := by
          apply mul_le_mul_of_nonneg_left _ (sq_nonneg C)
          nlinarith [sq_nonneg (diffuseDefect v x - S)]
        _ = _ := by ring
    have hy := sq_nonneg (inverseHessian v i j x + R)
    have hg := sq_nonneg ‖gradient (inverseHessian v i j) x‖
    change _ ≤ 2 * ‖gradient (inverseHessian v i j) x‖ ^ 2 + 2 * inverseHessian v i j x * R
    nlinarith
  rw [hessianSquare_drift_identity hv hi]
  have hsum := Finset.sum_le_sum (fun (i : Fin n) (_ : i ∈ Finset.univ) =>
    Finset.sum_le_sum (fun (j : Fin n) (_ : j ∈ Finset.univ) => hpair i j))
  apply le_trans _ hsum
  simp only [Finset.sum_sub_distrib, Finset.sum_neg_distrib, Finset.sum_const,
    Finset.card_univ, Fintype.card_fin, nsmul_eq_mul]
  rw [← hessianSquare_eq_sum]
  dsimp only [tensorBernsteinConstant]
  change -(1 + 2 * (n : ℝ) ^ 2 * C ^ 2) * (hessianSquare v x + diffuseDefect v x ^ 2) ≤ _
  nlinarith [sq_nonneg (diffuseDefect v x)]

lemma diffuseDefect_drift_upper {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) ≤
      2 * diffuseDefect v x - 2 * hessianSquare v x := by
  rw [diffuseDefect_laplacian hv hi hAC]
  have hD := diffuseDefect_nonneg (smooth_C2 hv) hi hAC x
  have hp := inverseProfile_gradient_bound (smooth_C2 hv) hi hAC x
  have hp0 := norm_nonneg (gradient (inverseProfile v) x)
  have hp2 : ‖gradient (inverseProfile v) x‖ ^ 2 ≤ 1 := by nlinarith
  have hq : defectWeight v x ≤ 1 := by dsimp [defectWeight]; nlinarith [sq_nonneg (v x)]
  have hq0 : 0 ≤ defectWeight v x := (weight_pos (hi x)).le
  have hh := mul_le_mul hq hp2 (sq_nonneg _) (by norm_num : (0 : ℝ) ≤ 1)
  have hfinal := mul_le_mul_of_nonneg_left hh (show 0 ≤ 2 * diffuseDefect v x by positivity)
  rw [diffuseDrift, map_smul, smul_eq_mul, ← inner_gradient_left, real_inner_comm]
  dsimp only [hessianSquare]
  nlinarith

theorem hessianSquare_le_defect {n : ℕ} {v : Space n → ℝ}
    (hv : ContDiff ℝ ∞ v) (hi : ∀ x, v x ∈ Set.Ioo (-1 : ℝ) 1) (hAC : AllenCahn v)
    (x : Space n) :
    hessianSquare v x ≤ (tensorBernsteinConstant n + 3) * diffuseDefect v x := by
  have hC : 0 ≤ tensorBernsteinConstant n := by dsimp [tensorBernsteinConstant]; positivity
  have H := quotient_bernstein
    (smooth_C2 (hessianSquare_smooth hv hi)) (smooth_C2 (diffuseDefect_smooth hv hi)) (diffuseDrift v)
    (show 0 ≤ (n : ℝ) * (12 * (2 * Real.sqrt 2 + 1)) ^ 2 by positivity)
    (show 0 ≤ 2 * Real.sqrt 2 by positivity)
    (show 0 ≤ 2 * (n : ℝ) ^ 2 * (12 * (2 * Real.sqrt 2 + 1)) by positivity)
    hC (by norm_num : (0 : ℝ) ≤ 2)
    (fun y => ⟨hessianSquare_nonneg v y, hessianSquare_uniform_bound hv hi hAC y⟩)
    (fun y => ⟨diffuseDefect_nonneg (smooth_C2 hv) hi hAC y, diffuseDefect_le_one v y⟩)
    (diffuseDrift_bound (smooth_C2 hv) hi hAC) (diffuseDefect_gradient_uniform_bound hv hi hAC)
    (hessianSquare_drift_lower hv hi hAC) (diffuseDefect_drift_upper hv hi hAC) x
  convert H using 1
  ring

lemma quotient_bernstein_linear {n : ℕ} {f d : Space n → ℝ}
    (hf : ContDiff ℝ 2 f) (hd : ContDiff ℝ 2 d) (b : Space n → Space n)
    {M B G A c : ℝ} (hM : 0 ≤ M) (hB : 0 ≤ B) (hG : 0 ≤ G)
    (hA : 0 ≤ A) (hc : 0 ≤ c)
    (hfb : ∀ x, 0 ≤ f x ∧ f x ≤ M) (hdb : ∀ x, 0 ≤ d x ∧ d x ≤ 1)
    (hbb : ∀ x, ‖b x‖ ≤ B) (hgb : ∀ x, ‖gradient d x‖ ≤ G)
    (hfde : ∀ x, -A * (f x + d x) ≤
      Laplacian.laplacian f x - fderiv ℝ f x (b x))
    (hdde : ∀ x, Laplacian.laplacian d x - fderiv ℝ d x (b x) ≤ c * d x - 2 * f x) :
    ∀ x, f x ≤ (A + c + 1) * d x := by
  have hδ {δ : ℝ} (hδ : 0 < δ) (x : Space n) : f x ≤ (A + c + 1) * (d x + δ) := by
    let e := fun y => d y + δ
    let w := fun y => f y / e y
    let b' := fun y => b y - (2 / e y) • gradient d y
    have he : ContDiff ℝ 2 e := hd.add contDiff_const
    have hep (y : Space n) : 0 < e y := by dsimp [e]; linarith [(hdb y).1]
    have heδ (y : Space n) : δ ≤ e y := by dsimp [e]; linarith [(hdb y).1]
    have hw : ContDiff ℝ 2 w := hf.div he (fun y => (hep y).ne')
    have hwe (y : Space n) : w y * e y = f y := by dsimp [w]; field_simp [(hep y).ne']
    have hwp (y : Space n) : 0 ≤ w y := div_nonneg (hfb y).1 (hep y).le
    have hwb (y : Space n) : |w y| ≤ M / δ := by
      rw [abs_of_nonneg (hwp y)]
      exact div_le_div₀ hM (hfb y).2 hδ (heδ y)
    have hb'b (y : Space n) : ‖b' y‖ ≤ B + 2 / δ * G := by
      calc ‖b' y‖ ≤ ‖b y‖ + ‖(2 / e y) • gradient d y‖ := norm_sub_le _ _
           _ = ‖b y‖ + 2 / e y * ‖gradient d y‖ := by
             rw [norm_smul, Real.norm_eq_abs, abs_of_pos (div_pos (by norm_num) (hep y))]
           _ ≤ B + 2 / δ * G := add_le_add (hbb y)
             (mul_le_mul (div_le_div_of_nonneg_left (by norm_num) hδ (heδ y)) (hgb y)
               (norm_nonneg _) (by positivity))
    have hele (y : Space n) : Laplacian.laplacian e y = Laplacian.laplacian d y := by
      rw [laplacian_fun_add hd contDiff_const]
      simp
    have hef (y : Space n) : fderiv ℝ e y = fderiv ℝ d y := by
      dsimp [e]
      rw [fderiv_fun_add (hd.differentiable (by norm_num) y) (differentiableAt_const δ)]
      simp
    have heg (y : Space n) : gradient e y = gradient d y := by simp only [gradient, hef]
    have hwde (y : Space n) : w y ^ 2 - (A + c) * w y - (A + c) ≤
        Laplacian.laplacian w y - fderiv ℝ w y (b' y) := by
      have hI := drift_quotient_identity hf he (fun z => (hep z).ne') b y
      change e y * (Laplacian.laplacian w y -
          fderiv ℝ w y (b y - (2 / e y) • gradient e y)) = _ - w y * _ at hI
      rw [heg, hele, hef] at hI
      have h₁ := hfde y
      have h₂ := mul_le_mul_of_nonneg_left (hdde y) (hwp y)
      have h₃ : d y ≤ e y := by dsimp [e]; linarith
      have h₄ : c * w y * d y ≤ c * w y * e y :=
        mul_le_mul_of_nonneg_left (by dsimp [e]; linarith) (mul_nonneg hc (hwp y))
      have h₅ := mul_le_mul_of_nonneg_left h₃ hA
      have h₆ : 0 ≤ w y ^ 2 * e y := mul_nonneg (sq_nonneg _) (hep y).le
      have h₇ : 0 ≤ c * e y := mul_nonneg hc (hep y).le
      apply (mul_le_mul_iff_right₀ (hep y)).mp
      dsimp only [b']
      rw [← hwe y] at h₁ h₂
      nlinarith
    have hh := bounded_drift_logistic hw b'
      (show 0 ≤ M / δ by positivity) (show 0 ≤ B + 2 / δ * G by positivity)
      (add_nonneg hA hc) hwb hb'b hwde x
    have hh' := mul_le_mul_of_nonneg_right hh (hep x).le
    rw [hwe] at hh'
    exact hh'
  intro x
  by_contra h
  have hh : 0 < f x - (A + c + 1) * d x := sub_pos.mpr (lt_of_not_ge h)
  let δ := (f x - (A + c + 1) * d x) / (2 * (A + c + 1))
  have hK : 0 < A + c + 1 := by linarith
  have hδp : 0 < δ := div_pos hh (by linarith)
  have hh' := hδ hδp x
  dsimp [δ] at hh'
  have hrel : (A + c + 1) * ((f x - (A + c + 1) * d x) / (2 * (A + c + 1))) =
      (f x - (A + c + 1) * d x) / 2 := by field_simp
  rw [mul_add, hrel] at hh'
  linarith

def C1Bound {n : ℕ} (f : Space n → ℝ) (C : ℝ) : Prop :=
  (∀ x, |f x| ≤ C) ∧ ∀ i x, |coordDeriv f i x| ≤ C

lemma C1Bound.mono {n : ℕ} {f : Space n → ℝ} {C K : ℝ}
    (h : C1Bound f C) (hCK : C ≤ K) : C1Bound f K :=
  ⟨fun x => (h.1 x).trans hCK, fun i x => (h.2 i x).trans hCK⟩

lemma C1Bound.const {n : ℕ} (c : ℝ) : C1Bound (fun _ : Space n => c) |c| := by
  constructor
  · intro x; rfl
  · intro i x; simp [coordDeriv]

lemma C1Bound.neg {n : ℕ} {f : Space n → ℝ} {C : ℝ}
    (hf : Differentiable ℝ f) (h : C1Bound f C) : C1Bound (fun x => -f x) C := by
  constructor
  · intro x; simpa using h.1 x
  · intro i x
    change |fderiv ℝ (-f) x (basis n i)| ≤ C
    rw [(hf x).hasFDerivAt.neg.fderiv]
    simpa only [neg_apply, abs_neg, coordDeriv] using h.2 i x

lemma C1Bound.mul {n : ℕ} {f g : Space n → ℝ} {C K : ℝ}
    (hf : Differentiable ℝ f) (hg : Differentiable ℝ g)
    (hC : 0 ≤ C) (hK : 0 ≤ K) (h : C1Bound f C) (h' : C1Bound g K) :
    C1Bound (fun x => f x * g x) (2 * C * K) := by
  constructor
  · intro x
    rw [abs_mul]
    have hh := mul_le_mul (h.1 x) (h'.1 x) (abs_nonneg _) hC
    nlinarith
  · intro i x
    rw [coordDeriv_mul hf hg]
    calc |f x * coordDeriv g i x + g x * coordDeriv f i x| ≤
        |f x * coordDeriv g i x| + |g x * coordDeriv f i x| := abs_add_le _ _
      _ ≤ C * K + K * C := by
        simp only [abs_mul]
        exact add_le_add (mul_le_mul (h.1 x) (h'.2 i x) (abs_nonneg _) hC)
          (mul_le_mul (h'.1 x) (h.2 i x) (abs_nonneg _) hK)
      _ = _ := by ring

lemma C1Bound.const_mul {n : ℕ} {f : Space n → ℝ} {C : ℝ}
    (hf : Differentiable ℝ f) (_hC : 0 ≤ C) (h : C1Bound f C) (a : ℝ) :
    C1Bound (fun x => a * f x) (|a| * C) := by
  constructor
  · intro x; rw [abs_mul]; exact mul_le_mul_of_nonneg_left (h.1 x) (abs_nonneg _)
  · intro i x
    change |fderiv ℝ (fun x => a * f x) x (basis n i)| ≤ _
    rw [fderiv_const_mul (hf x)]
    simp only [smul_apply, smul_eq_mul, abs_mul]
    change |a| * |coordDeriv f i x| ≤ _
    exact mul_le_mul_of_nonneg_left (h.2 i x) (abs_nonneg _)

lemma inverseHessian_gradient_uniform_bound {n : ℕ} {v : Space n → ℝ}
    (hv : ContDiff ℝ ∞ v) (hi : ∀ x, v x ∈ Set.Ioo (-1 : ℝ) 1) (hAC : AllenCahn v)
    (i j : Fin n) (x : Space n) :
    ‖gradient (inverseHessian v i j) x‖ ≤
      2 * (2 * (12 * (2 * Real.sqrt 2 + 1)) +
        tensorSystemConstant n * (1 + (n + 1) * (12 * (2 * Real.sqrt 2 + 1))) + 3) *
        (2 * Real.sqrt 2 + 1) := by
  let K := 12 * (2 * Real.sqrt 2 + 1)
  have hK : 0 ≤ K := by dsimp [K]; positivity
  have hC : 0 ≤ tensorSystemConstant n := by dsimp [tensorSystemConstant]; positivity
  apply PoissonSupport.DeGiorgi.bounded_drift_gradient
    (smooth_C2 (inverseHessian_smooth hv hi i j)) (diffuseDrift v) hK (by positivity)
    (by positivity) (inverseHessian_abs_le hv hi hAC i j) (diffuseDrift_bound (smooth_C2 hv) hi hAC)
  intro y
  apply (inverseHessian_drift_abs_bound hv hi hAC i j y).trans
  apply mul_le_mul_of_nonneg_left _ hC
  apply add_le_add (diffuseDefect_le_one v y)
  have hs := Real.sq_sqrt (hessianSquare_nonneg v y)
  have hh := hessianSquare_uniform_bound hv hi hAC y
  have hn : 0 ≤ (n : ℝ) := Nat.cast_nonneg n
  have hk : 0 ≤ (n + 1 : ℝ) * K := by positivity
  have hmul : (n : ℝ) * K ^ 2 ≤ ((n + 1 : ℝ) * K) ^ 2 := by
    nlinarith [mul_nonneg (sq_nonneg (n : ℝ)) (sq_nonneg K), mul_nonneg hn (sq_nonneg K)]
  change hessianSquare v y ≤ (n : ℝ) * K ^ 2 at hh
  nlinarith [Real.sqrt_nonneg (hessianSquare v y)]

def inverseJetConstant (n : ℕ) : ℝ :=
  1 + 12 * (2 * Real.sqrt 2 + 1) +
    2 * (n : ℝ) * (12 * (2 * Real.sqrt 2 + 1)) +
    2 * (2 * (12 * (2 * Real.sqrt 2 + 1)) +
      tensorSystemConstant n * (1 + (n + 1) * (12 * (2 * Real.sqrt 2 + 1))) + 3) *
      (2 * Real.sqrt 2 + 1)

lemma inverseJetConstant_one_le (n : ℕ) : 1 ≤ inverseJetConstant n := by
  change 1 ≤ 1 + _ + _ + _
  have ha : 0 ≤ 12 * (2 * Real.sqrt 2 + 1) := by positivity
  have hb : 0 ≤ 2 * (n : ℝ) * (12 * (2 * Real.sqrt 2 + 1)) := by positivity
  have hc : 0 ≤ tensorSystemConstant n := by dsimp [tensorSystemConstant]; positivity
  have hd : 0 ≤ 2 * (2 * (12 * (2 * Real.sqrt 2 + 1)) +
    tensorSystemConstant n * (1 + (n + 1) * (12 * (2 * Real.sqrt 2 + 1))) + 3) *
    (2 * Real.sqrt 2 + 1) := by positivity
  linarith

end DeGiorgi
end

end OAI