import OAI.Analysis.AllenCahn.Cutoffs

namespace OAI

noncomputable section
namespace DeGiorgi
open Filter Set Topology
open scoped NNReal
open scoped SchwartzMap Laplacian ContDiff
open FourierTransform
open scoped ContDiff
open Filter Topology

lemma unbounded_bernstein_bound {n : ℕ} {w : Space n → ℝ}
    (hw : ContDiff ℝ 2 w) (hw0 : ∀ x, 0 ≤ w x) (b : Space n → Space n)
    {L p B C : ℝ} (hL : 0 ≤ L) (hp : 0 ≤ p) (hB : 0 ≤ B) (hC : 0 ≤ C)
    (hb : ∀ x, ‖b x‖ ≤ B + C * Real.sqrt (w x))
    (heq : ∀ x, w x ^ 2 ≤ L * (1 + w x) +
      p * (Laplacian.laplacian w x - fderiv ℝ w x (b x))) :
    ∀ z, w z ≤ 2 * (L + p * (24 + 4 * n + 4 * B)) + (4 * p * C) ^ 2 + 2 * L + 1 := by
  intro z
  let r := unitCutoff z
  let F := fun x => r x ^ 2 * w x
  have hr : ContDiff ℝ 2 r := smooth_C2 (unitCutoff_smooth z)
  have hF : ContDiff ℝ 2 F := (hr.pow 2).mul hw
  have hz : z ∈ Metric.closedBall z (1 : ℝ) := by simp
  obtain ⟨x, hx, hmax⟩ := (isCompact_closedBall z (1 : ℝ)).exists_isMaxOn
    ⟨z, hz⟩ hF.continuous.continuousOn
  have hwx := hw0 x
  have hval : w z ≤ F x := by
    have H := hmax hz
    simpa [F,r,unitCutoff] using H
  by_cases hpz : w z ≤ 0
  · have hbound : 0 ≤ 2 * (L + p * (24 + 4 * n + 4 * B)) +
        (4 * p * C) ^ 2 + 2 * L + 1 := by positivity
    exact hpz.trans hbound
  have hpF : 0 < F x := lt_of_lt_of_le (lt_of_not_ge hpz) hval
  have hxn : ‖x - z‖ ≤ 1 := by simpa only [Metric.mem_closedBall, dist_eq_norm] using hx
  have hr0 : 0 ≤ r x := by dsimp [r,unitCutoff]; nlinarith [norm_nonneg (x-z)]
  have hrx : 0 < r x := by
    have hn : r x ≠ 0 := by
      intro hzero
      have : F x = 0 := by simp [F,hzero]
      linarith
    exact lt_of_le_of_ne hr0 (Ne.symm hn)
  have hr1 : r x ≤ 1 := by dsimp [r,unitCutoff]; nlinarith [sq_nonneg ‖x-z‖]
  have hxi : x ∈ Metric.ball z (1 : ℝ) := by
    simp only [Metric.mem_ball, dist_eq_norm]
    dsimp [r,unitCutoff] at hrx
    nlinarith [norm_nonneg (x-z)]
  have hlocal : IsLocalMax F x := hmax.isLocalMax
    (Filter.mem_of_superset (Metric.isOpen_ball.mem_nhds hxi) Metric.ball_subset_closedBall)
  have HC := cutoff_max_calculus hw hr hrx hlocal
  have hgn : ‖gradient r x‖ ≤ 2 := by
    change ‖gradient (unitCutoff z) x‖ ≤ 2
    rw [gradient_unitCutoff, norm_smul, Real.norm_eq_abs]
    norm_num
    linarith
  have hgn2 : ‖gradient r x‖ ^ 2 ≤ 4 := by nlinarith [norm_nonneg (gradient r x)]
  have hLap : r x ^ 2 * Laplacian.laplacian w x ≤ (24 + 4 * n) * w x := by
    apply HC.1.trans
    apply mul_le_mul_of_nonneg_right _ (hw0 x)
    change 6 * ‖gradient r x‖ ^ 2 - 2 * r x * Laplacian.laplacian (unitCutoff z) x ≤ _
    rw [laplacian_unitCutoff]
    have H := mul_le_mul_of_nonneg_left hr1 (show (0 : ℝ) ≤ 4 * n by positivity)
    nlinarith
  have hDer : -(r x ^ 2) * fderiv ℝ w x (b x) ≤
      4 * r x * w x * (B + C * Real.sqrt (w x)) := by
    rw [HC.2]
    have hd : fderiv ℝ r x (b x) ≤ 2 * (B + C * Real.sqrt (w x)) := by
      rw [← inner_gradient_left]
      exact (le_abs_self _).trans ((abs_real_inner_le_norm _ _).trans
        (mul_le_mul hgn (hb x) (norm_nonneg _) (by norm_num)))
    have H := mul_le_mul_of_nonneg_left hd (show 0 ≤ 2 * r x * w x by positivity)
    nlinarith
  exact hval.trans (cutoff_bernstein_algebra hrx hr1 (hw0 x) hL hp
    (by positivity) hB hC (heq x) hLap hDer)

def linearLogGradientBound (n : ℕ) (R : ℝ) : ℝ :=
  let N : ℝ := n + 1
  let L := 2 * R ^ 2 + N * R * n + 3 * N * R
  2 * (L + N * (24 + 4 * n)) + (8 * N) ^ 2 + 2 * L + 1

lemma log_gradient_bound_no_growth {n : ℕ} {h r : Space n → ℝ}
    (hh : ContDiff ℝ ∞ h) (hr : ContDiff ℝ ∞ r) {R : ℝ} (hR : 0 ≤ R)
    (heq : ∀ x, Laplacian.laplacian h x = r x - ‖gradient h x‖ ^ 2)
    (hrb : ∀ x, |r x| ≤ R) (hrd : ∀ i x, |coordDeriv r i x| ≤ R) :
    ∀ x, ‖gradient h x‖ ^ 2 ≤ linearLogGradientBound n R := by
  let N : ℝ := n + 1
  let L := 2 * R ^ 2 + N * R * n + 3 * N * R
  let w := fun x => ‖gradient h x‖ ^ 2
  let b := fun x => -(2 : ℝ) • gradient h x
  have hN : 0 ≤ N := by dsimp [N]; positivity
  have hL : 0 ≤ L := by dsimp [L,N]; positivity
  have hw : ContDiff ℝ 2 w := smooth_C2 (gradient_norm_sq_smooth hh)
  have hb : ∀ x, ‖b x‖ ≤ 0 + 2 * Real.sqrt (w x) := by
    intro x
    simp [b,w, norm_smul, Real.sqrt_sq (norm_nonneg (gradient h x))]
  have hP (x : Space n) : w x ^ 2 ≤ L * (1 + w x) +
      N * (Laplacian.laplacian w x - fderiv ℝ w x (b x)) := by
    let H := ∑ i : Fin n, ‖gradient (coordDeriv h i) x‖ ^ 2
    have hH : 0 ≤ H := Finset.sum_nonneg (fun _ _ => sq_nonneg _)
    have htr := laplacian_sq_le_hessian hh x
    change Laplacian.laplacian h x ^ 2 ≤ n * H at htr
    have hr2 : r x ^ 2 ≤ R ^ 2 := by
      simpa only [sq_abs] using pow_le_pow_left₀ (abs_nonneg (r x)) (hrb x) 2
    have he := heq x
    change Laplacian.laplacian h x = r x - w x at he
    have hsq : w x ^ 2 ≤ 2 * R ^ 2 + 2 * N * H := by
      have hbasic : w x ^ 2 ≤ 2 * r x ^ 2 + 2 * Laplacian.laplacian h x ^ 2 := by
        rw [he]
        nlinarith [sq_nonneg (2 * r x - w x)]
      dsimp [N]
      nlinarith
    have hbo := log_bochner_lower (v := fun _ : Space n => 0)
      contDiff_const (fun _ => by constructor <;> norm_num) hh hr hR (le_refl (0 : ℝ))
      (fun y => by simpa [diffuseDrift] using heq y)
      (fun i y => (hrd i y).trans (by nlinarith [mul_nonneg hR (abs_nonneg (coordDeriv h i y))]))
      (fun i k y => by
        have hz : driftCoeff (fun _ : Space n => (0 : ℝ)) k = fun _ => 0 := by
          funext t; simp [driftCoeff]
        rw [hz]
        simp [coordDeriv]) x
    have hbo' : 2 * H ≤ Laplacian.laplacian w x - fderiv ℝ w x (b x) + R * n + 3 * R * w x := by
      have H' : 2 * H - R * n - 3 * R * w x ≤
          Laplacian.laplacian w x - fderiv ℝ w x (b x) := by
        simpa [H,w,b,diffuseDrift] using hbo
      linarith
    have hmul := mul_le_mul_of_nonneg_left hbo' hN
    have hlin : 2 * R ^ 2 + N * R * n + 3 * N * R * w x ≤ L * (1 + w x) := by
      have hw0 : 0 ≤ w x := sq_nonneg _
      have ha : 0 ≤ (2 * R ^ 2 + N * R * n) * w x := by positivity
      have hc : 0 ≤ 3 * N * R := by positivity
      dsimp [L]
      nlinarith
    nlinarith
  have HB := unbounded_bernstein_bound hw (fun x => sq_nonneg _) b hL hN
    (le_refl (0 : ℝ)) (by norm_num : (0 : ℝ) ≤ 2) hb hP
  intro x
  convert HB x using 1
  dsimp [linearLogGradientBound,L,N,w]
  ring

lemma linearLogGradientBound_nonneg (n : ℕ) {R : ℝ} (hR : 0 ≤ R) :
    0 ≤ linearLogGradientBound n R := by
  dsimp [linearLogGradientBound]
  positivity

lemma positive_linear_log_gradient {n : ℕ} {f P : Space n → ℝ}
    (hf : ContDiff ℝ ∞ f) (hP : ContDiff ℝ ∞ P) (hp : ∀ x, 0 < f x)
    {R : ℝ} (hR : 0 ≤ R) (hPb : ∀ x, |P x| ≤ R)
    (hPd : ∀ i x, |coordDeriv P i x| ≤ R)
    (heq : ∀ x, Laplacian.laplacian f x = P x * f x) :
    ∀ x, ‖gradient (fun y => Real.log (f y)) x‖ ≤
      Real.sqrt (linearLogGradientBound n R) := by
  have hh : ContDiff ℝ ∞ (fun y => Real.log (f y)) := hf.log (fun x => (hp x).ne')
  have hlog (x : Space n) : Laplacian.laplacian (fun y => Real.log (f y)) x =
      P x - ‖gradient (fun y => Real.log (f y)) x‖ ^ 2 := by
    have H := drift_log (smooth_C2 hf) (fun y => (hp y).ne') (fun _ => 0) x
    simpa [heq x, (hp x).ne'] using H
  have H := log_gradient_bound_no_growth hh hP hR hlog hPb hPd
  intro x
  exact (Real.le_sqrt (norm_nonneg _) (linearLogGradientBound_nonneg n hR)).mpr (H x)

lemma positive_linear_log_lipschitz {n : ℕ} {f P : Space n → ℝ}
    (hf : ContDiff ℝ ∞ f) (hP : ContDiff ℝ ∞ P) (hp : ∀ x, 0 < f x)
    {R : ℝ} (hR : 0 ≤ R) (hPb : ∀ x, |P x| ≤ R)
    (hPd : ∀ i x, |coordDeriv P i x| ≤ R)
    (heq : ∀ x, Laplacian.laplacian f x = P x * f x) (x y : Space n) :
    |Real.log (f y) - Real.log (f x)| ≤
      Real.sqrt (linearLogGradientBound n R) * ‖y - x‖ := by
  have hh : ContDiff ℝ ∞ (fun y => Real.log (f y)) := hf.log (fun x => (hp x).ne')
  have H := Convex.norm_image_sub_le_of_norm_fderiv_le
    (s := Set.univ) (fun z _ => hh.differentiable (by simp) z)
    (fun z _ => show ‖fderiv ℝ (fun y => Real.log (f y)) z‖ ≤
        Real.sqrt (linearLogGradientBound n R) by
      simpa only [gradient, LinearIsometryEquiv.norm_map] using
        positive_linear_log_gradient hf hP hp hR hPb hPd heq z)
    convex_univ (Set.mem_univ x) (Set.mem_univ y)
  exact H

lemma positive_linear_harnack {n : ℕ} {f P : Space n → ℝ}
    (hf : ContDiff ℝ ∞ f) (hP : ContDiff ℝ ∞ P) (hp : ∀ x, 0 < f x)
    {R : ℝ} (hR : 0 ≤ R) (hPb : ∀ x, |P x| ≤ R)
    (hPd : ∀ i x, |coordDeriv P i x| ≤ R)
    (heq : ∀ x, Laplacian.laplacian f x = P x * f x) (x y : Space n) :
    f y ≤ Real.exp (Real.sqrt (linearLogGradientBound n R) * ‖y - x‖) * f x := by
  have H := (abs_le.mp (positive_linear_log_lipschitz hf hP hp hR hPb hPd heq x y)).2
  have HH := Real.exp_le_exp.mpr H
  rw [Real.exp_sub, Real.exp_log (hp y), Real.exp_log (hp x)] at HH
  exact (div_le_iff₀ (hp x)).mp HH

lemma positive_linear_relative_gradient {n : ℕ} {f P : Space n → ℝ}
    (hf : ContDiff ℝ ∞ f) (hP : ContDiff ℝ ∞ P) (hp : ∀ x, 0 < f x)
    {R : ℝ} (hR : 0 ≤ R) (hPb : ∀ x, |P x| ≤ R)
    (hPd : ∀ i x, |coordDeriv P i x| ≤ R)
    (heq : ∀ x, Laplacian.laplacian f x = P x * f x) (x : Space n) :
    ‖gradient f x‖ ≤ Real.sqrt (linearLogGradientBound n R) * f x := by
  have H := positive_linear_log_gradient hf hP hp hR hPb hPd heq x
  rw [gradient_log (hf.differentiable (by simp) x) (hp x).ne', norm_smul,
    Real.norm_eq_abs, abs_inv, abs_of_pos (hp x)] at H
  have HH := mul_le_mul_of_nonneg_left H (hp x).le
  simpa [mul_assoc, (hp x).ne', mul_comm] using HH

end DeGiorgi
end

end OAI