lean/OAI/Analysis/AllenCahn/SechSpectrum.lean

import OAI.Analysis.AllenCahn.PositiveCone

namespace OAI

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

lemma positive_sech_ode_spectral {f : ℝ → ℝ} {lam : ℝ}
    (hf : ContDiff ℝ 2 f) (hp : ∀ y, 0 < f y)
    (heq : ∀ y, deriv (deriv f) y = (lam - 2 * sech y ^ 2) * f y) : 1 ≤ lam := by
  by_contra hlam
  have hlam : lam < 1 := lt_of_not_ge hlam
  have hfd : Differentiable ℝ f := hf.differentiable (by norm_num)
  have hfdd : Differentiable ℝ (deriv f) := hf.differentiable_deriv_two
  let W := fun y => deriv f y * sech y - f y * deriv sech y
  let w := fun y => f y * Real.cosh y
  have hsd : Differentiable ℝ sech := contDiff_sech.differentiable (by simp)
  have hWd (y) : HasDerivAt W ((lam-1)*f y*sech y) y := by
    have H := ((hfdd y).hasDerivAt.mul (sech_hasDerivAt y)).sub
      ((hfd y).hasDerivAt.mul (sech_hasDerivAt_twice y))
    change HasDerivAt W (deriv (deriv f) y * sech y + deriv f y *
      (-Real.sinh y / Real.cosh y ^ 2) -
      (deriv f y * deriv sech y + f y * ((1 - 2 * sech y ^ 2) * sech y))) y at H
    rw [heq y, ← sech_deriv y] at H
    have he : (lam - 2 * sech y ^ 2) * f y * sech y + deriv f y * deriv sech y -
      (deriv f y * deriv sech y + f y * ((1 - 2 * sech y ^ 2) * sech y)) =
      (lam-1)*f y*sech y := by ring
    rwa [he] at H
  have hW : Antitone W := antitone_of_deriv_nonpos
    (fun y => (hWd y).differentiableAt) (fun y => by
      rw [(hWd y).deriv]; exact le_of_lt (mul_neg_of_neg_of_pos
        (mul_neg_of_neg_of_pos (by linarith) (hp y)) (sech_pos y)))
  have hwd (y) : HasDerivAt w (W y * Real.cosh y ^ 2) y := by
    have H := (hfd y).hasDerivAt.mul (Real.hasDerivAt_cosh y)
    change HasDerivAt w (deriv f y * Real.cosh y + f y * Real.sinh y) y at H
    have he : deriv f y * Real.cosh y + f y * Real.sinh y = W y * Real.cosh y ^ 2 := by
      dsimp [W]
      rw [sech_deriv]
      dsimp [sech]
      field_simp
      ring
    rwa [he] at H
  have hzero := positive_antitone_flux_zero (fun y => (hwd y).differentiableAt)
    (fun y => mul_pos (hp y) (Real.cosh_pos y)) hW cosh_sq_ge_one
    (fun y => (hwd y).deriv)
  have hconst : W = fun _ => 0 := funext hzero
  have hs : (lam-1)*f 0*sech 0 = 0 := by
    have H := (hWd 0).deriv
    rw [hconst, deriv_const] at H
    exact H.symm
  have hn : (lam-1)*f 0*sech 0 < 0 := mul_neg_of_neg_of_pos
    (mul_neg_of_neg_of_pos (by linarith) (hp 0)) (sech_pos 0)
  linarith

lemma positive_sech_ode_endpoint {f : ℝ → ℝ}
    (hf : ContDiff ℝ 2 f) (hp : ∀ y, 0 < f y)
    (heq : ∀ y, deriv (deriv f) y = (1 - 2 * sech y ^ 2) * f y) :
    ∀ y, f y = f 0 * sech y := by
  have hfd := hf.differentiable (by norm_num : (2 : ℕ∞ω) ≠ 0)
  have hfdd := hf.differentiable_deriv_two
  let W := fun y => deriv f y * sech y - f y * deriv sech y
  let w := fun y => f y * Real.cosh y
  have hWd (y) : HasDerivAt W 0 y := by
    have H := ((hfdd y).hasDerivAt.mul (sech_hasDerivAt y)).sub
      ((hfd y).hasDerivAt.mul (sech_hasDerivAt_twice y))
    change HasDerivAt W (deriv (deriv f) y * sech y + deriv f y *
      (-Real.sinh y / Real.cosh y ^ 2) -
      (deriv f y * deriv sech y + f y * ((1 - 2 * sech y ^ 2) * sech y))) y at H
    rw [heq y, ← sech_deriv y] at H
    have he : (1 - 2 * sech y ^ 2) * f y * sech y + deriv f y * deriv sech y -
      (deriv f y * deriv sech y + f y * ((1 - 2 * sech y ^ 2) * sech y)) = 0 := by ring
    rwa [he] at H
  have hW : Antitone W := antitone_of_deriv_nonpos
    (fun y => (hWd y).differentiableAt) (fun y => by rw [(hWd y).deriv])
  have hwd (y) : HasDerivAt w (W y * Real.cosh y ^ 2) y := by
    have H := (hfd y).hasDerivAt.mul (Real.hasDerivAt_cosh y)
    change HasDerivAt w (deriv f y * Real.cosh y + f y * Real.sinh y) y at H
    have he : deriv f y * Real.cosh y + f y * Real.sinh y = W y * Real.cosh y ^ 2 := by
      dsimp [W]
      rw [sech_deriv]
      dsimp [sech]
      field_simp
      ring
    rwa [he] at H
  have hzero := positive_antitone_flux_zero (fun y => (hwd y).differentiableAt)
    (fun y => mul_pos (hp y) (Real.cosh_pos y)) hW cosh_sq_ge_one
    (fun y => (hwd y).deriv)
  intro y
  have H := is_const_of_deriv_eq_zero (fun y => (hwd y).differentiableAt)
    (fun y => by rw [(hwd y).deriv, hzero y, zero_mul]) y 0
  dsimp [w] at H
  simp only [Real.cosh_zero, mul_one] at H
  dsimp [sech]
  rw [← H]
  field_simp

lemma wronskian_eq_initial {V f g : ℝ → ℝ}
    (hf : ContDiff ℝ 2 f) (hg : ContDiff ℝ 2 g)
    (hfe : ∀ y, deriv (deriv f) y = V y * f y)
    (hge : ∀ y, deriv (deriv g) y = V y * g y) (y : ℝ) :
    deriv f y * g y - f y * deriv g y = deriv f 0 * g 0 - f 0 * deriv g 0 := by
  let W := fun y => deriv f y * g y - f y * deriv g y
  have hd (y) : HasDerivAt W 0 y := by
    have H := ((hf.differentiable_deriv_two y).hasDerivAt.mul
      ((hg.differentiable (by norm_num)) y).hasDerivAt).sub
      (((hf.differentiable (by norm_num)) y).hasDerivAt.mul
        (hg.differentiable_deriv_two y).hasDerivAt)
    change HasDerivAt W (deriv (deriv f) y * g y + deriv f y * deriv g y -
      (deriv f y * deriv g y + f y * deriv (deriv g) y)) y at H
    rw [hfe y, hge y] at H
    have he : V y * f y * g y + deriv f y * deriv g y -
      (deriv f y * deriv g y + f y * (V y * g y)) = 0 := by ring
    rwa [he] at H
  exact is_const_of_deriv_eq_zero (fun y => (hd y).differentiableAt)
    (fun y => (hd y).deriv) y 0

lemma ode_basis_expansion {V f g h : ℝ → ℝ}
    (hf : ContDiff ℝ 2 f) (hg : ContDiff ℝ 2 g) (hh : ContDiff ℝ 2 h)
    (hfe : ∀ y, deriv (deriv f) y = V y * f y)
    (hge : ∀ y, deriv (deriv g) y = V y * g y)
    (hhe : ∀ y, deriv (deriv h) y = V y * h y)
    (hdet : deriv g 0 * h 0 - g 0 * deriv h 0 ≠ 0) :
    ∀ y, f y = ((deriv f 0 * h 0 - f 0 * deriv h 0) /
        (deriv g 0 * h 0 - g 0 * deriv h 0)) * g y +
      ((deriv g 0 * f 0 - g 0 * deriv f 0) /
        (deriv g 0 * h 0 - g 0 * deriv h 0)) * h y := by
  intro y
  have Hfg := wronskian_eq_initial hf hh hfe hhe y
  have Hgh := wronskian_eq_initial hg hh hge hhe y
  have Hgf := wronskian_eq_initial hg hf hge hfe y
  rw [div_mul_eq_mul_div, div_mul_eq_mul_div, ← add_div]
  apply (eq_div_iff hdet).mpr
  nlinarith [congrArg (fun t => t * f y) Hgh,
    congrArg (fun t => t * g y) Hfg, congrArg (fun t => t * h y) Hgf]

lemma contDiff_tanh : ContDiff ℝ ∞ Real.tanh := by
  have H : Real.tanh = fun y => Real.sinh y / Real.cosh y := funext Real.tanh_eq_sinh_div_cosh
  rw [H]
  exact Real.contDiff_sinh.div Real.contDiff_cosh (fun y => (Real.cosh_pos y).ne')

lemma tanh_hasDerivAt (y : ℝ) : HasDerivAt Real.tanh (sech y ^ 2) y := by
  have H := (Real.hasDerivAt_sinh y).div (Real.hasDerivAt_cosh y) (Real.cosh_pos y).ne'
  change HasDerivAt (fun z => Real.sinh z / Real.cosh z)
    ((Real.cosh y * Real.cosh y - Real.sinh y * Real.sinh y) / Real.cosh y ^ 2) y at H
  have he : (Real.cosh y * Real.cosh y - Real.sinh y * Real.sinh y) / Real.cosh y ^ 2 = sech y ^ 2 := by
    rw [← pow_two, ← pow_two, Real.cosh_sq_sub_sinh_sq]
    simp [sech, one_div]
  rw [he, ← funext Real.tanh_eq_sinh_div_cosh] at H
  exact H

lemma sech_sq_tanh (y : ℝ) : sech y ^ 2 + Real.tanh y ^ 2 = 1 := by
  rw [Real.tanh_eq_sinh_div_cosh]
  dsimp [sech]
  field_simp
  nlinarith [Real.cosh_sq_sub_sinh_sq y]

def jost (a y : ℝ) : ℝ := Real.exp (a*y) * (a-Real.tanh y)

lemma contDiff_jost (a : ℝ) : ContDiff ℝ ∞ (jost a) :=
  (Real.contDiff_exp.comp (contDiff_const.mul contDiff_id)).mul (contDiff_const.sub contDiff_tanh)

lemma jost_hasDerivAt (a y : ℝ) :
    HasDerivAt (jost a) (Real.exp (a*y) * (a*(a-Real.tanh y)-sech y^2)) y := by
  have H := ((hasDerivAt_id y).const_mul a).exp.mul ((hasDerivAt_const y a).sub (tanh_hasDerivAt y))
  change HasDerivAt (jost a)
    (Real.exp (a * y) * (a * 1) * (a - Real.tanh y) + Real.exp (a*y) * (0-sech y^2)) y at H
  convert H using 1
  ring

lemma jost_deriv (a y : ℝ) : deriv (jost a) y =
    Real.exp (a*y) * (a*(a-Real.tanh y)-sech y^2) := (jost_hasDerivAt a y).deriv

lemma sech_hasDerivAt' (y : ℝ) : HasDerivAt sech (-sech y * Real.tanh y) y := by
  have H := sech_hasDerivAt y
  have he : -Real.sinh y / Real.cosh y ^ 2 = -sech y * Real.tanh y := by
    rw [Real.tanh_eq_sinh_div_cosh]
    dsimp [sech]
    field_simp
  rwa [he] at H

lemma jost_hasDerivAt_twice (a y : ℝ) :
    HasDerivAt (deriv (jost a)) ((a^2-2*sech y^2)*jost a y) y := by
  have H := ((hasDerivAt_id y).const_mul a).exp.mul
    ((((hasDerivAt_const y a).sub (tanh_hasDerivAt y)).const_mul a).sub ((sech_hasDerivAt' y).pow 2))
  change HasDerivAt (fun z => Real.exp (a*z)*(a*(a-Real.tanh z)-sech z^2))
    (Real.exp (a*y)*(a*1)*(a*(a-Real.tanh y)-sech y^2) +
      Real.exp (a*y)*(a*(0-sech y^2) - 2*sech y^(2-1)*(-sech y*Real.tanh y))) y at H
  have he : Real.exp (a*y)*(a*1)*(a*(a-Real.tanh y)-sech y^2) +
      Real.exp (a*y)*(a*(0-sech y^2) - 2*sech y^(2-1)*(-sech y*Real.tanh y)) =
      (a^2-2*sech y^2)*jost a y := by dsimp [jost]; ring
  rw [he, ← funext (jost_deriv a)] at H
  exact H

def jostReflected (a y : ℝ) : ℝ := Real.exp (-a*y) * (a+Real.tanh y)

lemma jost_neg_parameter (a y : ℝ) : -jost (-a) y = jostReflected a y := by
  dsimp [jost, jostReflected]; ring

lemma jost_reflection (a y : ℝ) : jost a (-y) = jostReflected a y := by
  simp only [jost, jostReflected, Real.tanh_neg]
  congr 1 <;> congr 1 <;> ring

lemma contDiff_jostReflected (a : ℝ) : ContDiff ℝ ∞ (jostReflected a) := by
  rw [← funext (jost_neg_parameter a)]
  exact (contDiff_jost (-a)).neg

lemma jostReflected_deriv (a y : ℝ) : deriv (jostReflected a) y = -deriv (jost (-a)) y := by
  rw [← funext (jost_neg_parameter a)]
  exact deriv.fun_neg

lemma jost_ode (a y : ℝ) : deriv (deriv (jost a)) y = (a^2-2*sech y^2)*jost a y :=
  (jost_hasDerivAt_twice a y).deriv

lemma jostReflected_ode (a y : ℝ) : deriv (deriv (jostReflected a)) y =
    (a^2-2*sech y^2)*jostReflected a y := by
  rw [funext (jostReflected_deriv a), deriv.fun_neg, jost_ode]
  rw [← jost_neg_parameter]
  ring

lemma jost_pos {a : ℝ} (ha : 1 < a) (y : ℝ) : 0 < jost a y :=
  mul_pos (Real.exp_pos _) (by linarith [Real.tanh_lt_one y])

lemma jostReflected_pos {a : ℝ} (ha : 1 < a) (y : ℝ) : 0 < jostReflected a y :=
  mul_pos (Real.exp_pos _) (by linarith [Real.neg_one_lt_tanh y])

lemma jost_at_zero (a : ℝ) : jost a 0 = a := by simp [jost]

lemma jostReflected_at_zero (a : ℝ) : jostReflected a 0 = a := by simp [jostReflected]

lemma jost_deriv_at_zero (a : ℝ) : deriv (jost a) 0 = a^2-1 := by
  rw [jost_deriv]; simp [sech]; ring

lemma jostReflected_deriv_at_zero (a : ℝ) : deriv (jostReflected a) 0 = -(a^2-1) := by
  rw [jostReflected_deriv, jost_deriv_at_zero]; ring

lemma jost_scale (a y : ℝ) : jost a y * Real.exp (-a*y) = a-Real.tanh y := by
  dsimp [jost]
  rw [mul_right_comm, ← Real.exp_add]
  have he : a*y+-a*y=0 := by ring
  rw [he, Real.exp_zero, one_mul]

lemma jostReflected_scale (a y : ℝ) : jostReflected a y * Real.exp (-a*y) =
    Real.exp ((-2*a)*y) * (a+Real.tanh y) := by
  dsimp [jostReflected]
  rw [mul_right_comm, ← Real.exp_add]
  congr 2
  ring

lemma positive_jost_combination_first_nonneg {a A B : ℝ} (ha : 1 < a)
    (hp : ∀ y, 0 < A*jost a y+B*jostReflected a y) : 0 ≤ A := by
  by_contra hA
  have hA : A < 0 := lt_of_not_ge hA
  have H (y) : 0 ≤ A*(a-1) + (|B| *(a+1))*Real.exp ((-2*a)*y) := by
    have H := mul_pos (hp y) (Real.exp_pos (-a*y))
    rw [add_mul, mul_assoc, jost_scale, mul_assoc, jostReflected_scale] at H
    have H₁ : A*(a-Real.tanh y) ≤ A*(a-1) :=
      mul_le_mul_of_nonpos_left (by linarith [Real.tanh_lt_one y]) hA.le
    have H₂ : B*(Real.exp ((-2*a)*y)*(a+Real.tanh y)) ≤
        (|B| *(a+1))*Real.exp ((-2*a)*y) := by
      calc
        B*(Real.exp ((-2*a)*y)*(a+Real.tanh y)) ≤
            |B| *(Real.exp ((-2*a)*y)*(a+Real.tanh y)) :=
          mul_le_mul_of_nonneg_right (le_abs_self B) (by
            exact mul_nonneg (Real.exp_pos _).le (by linarith [Real.neg_one_lt_tanh y]))
        _ ≤ |B| *(Real.exp ((-2*a)*y)*(a+1)) := by
          exact mul_le_mul_of_nonneg_left (mul_le_mul_of_nonneg_left
            (by linarith [Real.tanh_lt_one y]) (Real.exp_pos _).le) (abs_nonneg B)
        _ = _ := by ring
    linarith
  have ht : Tendsto (fun y : ℝ => Real.exp ((-2*a)*y)) atTop (𝓝 0) :=
    Real.tendsto_exp_atBot.comp (tendsto_id.const_mul_atTop_of_neg (by linarith))
  have hlim : Tendsto (fun y : ℝ => A*(a-1)+(|B| *(a+1))*Real.exp ((-2*a)*y))
      atTop (𝓝 (A*(a-1))) := by simpa using tendsto_const_nhds.add (ht.const_mul (|B| *(a+1)))
  have HH := ge_of_tendsto hlim (Eventually.of_forall H)
  nlinarith

lemma positive_sech_ode_classification {f : ℝ → ℝ} {a : ℝ} (ha : 1 < a)
    (hf : ContDiff ℝ 2 f) (hp : ∀ y, 0 < f y)
    (heq : ∀ y, deriv (deriv f) y = (a^2-2*sech y^2)*f y) :
    ∃ A B : ℝ, 0 ≤ A ∧ 0 ≤ B ∧ (0 < A ∨ 0 < B) ∧
      ∀ y, f y = A*jost a y+B*jostReflected a y := by
  have hdet : deriv (jost a) 0 * jostReflected a 0 -
      jost a 0 * deriv (jostReflected a) 0 ≠ 0 := by
    rw [jost_deriv_at_zero, jostReflected_at_zero, jost_at_zero,
      jostReflected_deriv_at_zero]
    have : 0 < (a^2-1)*a-a*-(a^2-1) := by nlinarith
    exact this.ne'
  obtain hrep := ode_basis_expansion hf ((contDiff_jost a).of_le (show (2 : ℕ∞ω) ≤ ∞ from WithTop.coe_le_coe.mpr (by simp)))
    ((contDiff_jostReflected a).of_le (show (2 : ℕ∞ω) ≤ ∞ from WithTop.coe_le_coe.mpr (by simp))) heq (jost_ode a) (jostReflected_ode a) hdet
  set A := (deriv f 0 * jostReflected a 0 - f 0 * deriv (jostReflected a) 0) /
      (deriv (jost a) 0 * jostReflected a 0 - jost a 0 * deriv (jostReflected a) 0)
  set B := (deriv (jost a) 0 * f 0 - jost a 0 * deriv f 0) /
      (deriv (jost a) 0 * jostReflected a 0 - jost a 0 * deriv (jostReflected a) 0)
  have hrep' (y) : f y = A*jost a y+B*jostReflected a y := hrep y
  have hA := positive_jost_combination_first_nonneg ha (fun y => by rw [← hrep']; exact hp y)
  have hB := positive_jost_combination_first_nonneg (A := B) (B := A) ha (fun y => by
    have H := hp (-y)
    rw [hrep', jost_reflection] at H
    have hh : jostReflected a (-y) = jost a y := by rw [← jost_reflection, neg_neg]
    rw [hh, add_comm] at H
    exact H)
  refine ⟨A, B, hA, hB, ?_, hrep'⟩
  have H := hp 0
  rw [hrep', jost_at_zero, jostReflected_at_zero] at H
  by_contra hh
  simp only [not_or, not_lt] at hh
  nlinarith

end DeGiorgi
end

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

lemma laplacian_separated {n : ℕ} {f : ℝ → ℝ} (hf : ContDiff ℝ 2 f)
    (b c x : Space n) :
    Laplacian.laplacian (fun z => Real.exp (inner ℝ b z)*f (inner ℝ c z)) x =
      Real.exp (inner ℝ b x) *
        (deriv (deriv f) (inner ℝ c x)*‖c‖^2 +
          2*deriv f (inner ℝ c x)*inner ℝ b c + f (inner ℝ c x)*‖b‖^2) := by
  have hbi : ContDiff ℝ 2 (fun z : Space n => inner ℝ b z) := (innerSL ℝ b).contDiff
  have hci : ContDiff ℝ 2 (fun z : Space n => inner ℝ c z) := (innerSL ℝ c).contDiff
  have hfd := hf.differentiable (by norm_num)
  have hcomp : ContDiff ℝ 2 (fun z : Space n => f (inner ℝ c z)) := hf.comp hci
  rw [laplacian_fun_mul hbi.exp hcomp,
    laplacian_comp_scalar hci hcomp (fun x => hfd _) (fun x => hf.differentiable_deriv_two _),
    laplacian_exp hbi, gradient_inner, gradient_inner, laplacian_inner, laplacian_inner,
    gradient_comp_inner Real.differentiable_exp, gradient_comp_inner hfd]
  simp only [Real.deriv_exp, real_inner_smul_left, real_inner_smul_right]
  ring

def conePotential {n : ℕ} (ν : Space n) (x : Space n) : ℝ :=
  1 + Real.tanh (inner ℝ ν x / Real.sqrt 2)^2

lemma conePotential_smooth {n : ℕ} (ν : Space n) : ContDiff ℝ ∞ (conePotential ν) := by
  exact contDiff_const.add ((contDiff_tanh.comp ((innerSL ℝ ν).contDiff.div_const _)).pow 2)

lemma conePotential_bounds {n : ℕ} (ν : Space n) (x : Space n) :
    1 ≤ conePotential ν x ∧ conePotential ν x ≤ 2 := by
  dsimp [conePotential]
  constructor
  · nlinarith [sq_nonneg (Real.tanh (inner ℝ ν x / Real.sqrt 2))]
  · linarith [Real.tanh_sq_lt_one (inner ℝ ν x / Real.sqrt 2)]

end DeGiorgi
end

end OAI