import OAI.Analysis.AllenCahn.BernsteinGradient
import OAI.Analysis.AllenCahn.StrongMaximum

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

def positiveLinearCone {n : ℕ} (P : Space n → ℝ) : Set (Space n → ℝ) :=
  {f | ContDiff ℝ ∞ f ∧ (∀ x, 0 ≤ f x) ∧
    (∀ x, Laplacian.laplacian f x = P x * f x) ∧ f 0 = 1}

lemma positiveLinearCone_pos {n : ℕ} {P f : Space n → ℝ}
    (hP : ∀ x, P x ≤ 2) (hf : f ∈ positiveLinearCone P) : ∀ x, 0 < f x := by
  intro x
  by_contra h
  have hz : f x = 0 := le_antisymm (le_of_not_gt h) (hf.2.1 x)
  have hh := PositiveMaximum.nonnegative_supersolution_eq_zero (smooth_C2 hf.1) hf.2.1
    (fun y => by rw [hf.2.2.1 y]; exact mul_le_mul_of_nonneg_right (hP y) (hf.2.1 y)) hz 0
  rw [hf.2.2.2] at hh
  norm_num at hh

lemma positiveLinearCone_convex {n : ℕ} (P : Space n → ℝ) :
    Convex ℝ (positiveLinearCone P) := by
  intro f hf g hg a b ha hb hab
  have hs : ContDiff ℝ ∞ (a • f + b • g) := (hf.1.const_smul a).add (hg.1.const_smul b)
  refine ⟨hs, fun x => ?_, fun x => ?_, ?_⟩
  · change 0 ≤ a * f x + b * g x
    exact add_nonneg (mul_nonneg ha (hf.2.1 x)) (mul_nonneg hb (hg.2.1 x))
  · change Laplacian.laplacian (fun y => a * f y + b * g y) x = _
    rw [laplacian_fun_add (contDiff_const.mul (smooth_C2 hf.1)) (contDiff_const.mul (smooth_C2 hg.1)),
      laplacian_fun_const_mul (smooth_C2 hf.1), laplacian_fun_const_mul (smooth_C2 hg.1),
      hf.2.2.1, hg.2.2.1]
    simp only [Pi.add_apply, Pi.smul_apply, smul_eq_mul]
    ring
  · simpa only [Pi.add_apply, Pi.smul_apply, smul_eq_mul, hf.2.2.2, hg.2.2.2, mul_one] using hab

lemma positiveLinearCone_normalize {n : ℕ} {P f : Space n → ℝ}
    (hf : ContDiff ℝ ∞ f) (hp : ∀ x, 0 ≤ f x)
    (heq : ∀ x, Laplacian.laplacian f x = P x * f x) (h0 : 0 < f 0) :
    (fun x => (f 0)⁻¹ * f x) ∈ positiveLinearCone P := by
  refine ⟨contDiff_const.mul hf, fun x => mul_nonneg (inv_nonneg.mpr h0.le) (hp x), ?_, ?_⟩
  · intro x
    rw [laplacian_fun_const_mul (smooth_C2 hf), heq x]
    ring
  · exact inv_mul_cancel₀ h0.ne'

lemma positiveLinearCone_extreme_translate {n : ℕ} {P f : Space n → ℝ}
    (hP : ContDiff ℝ ∞ P) {R : ℝ} (hR : 0 ≤ R)
    (hPb : ∀ x, |P x| ≤ R) (hPd : ∀ i x, |coordDeriv P i x| ≤ R)
    (hP2 : ∀ x, P x ≤ 2)
    (hf : f ∈ (positiveLinearCone P).extremePoints ℝ)
    (t : Space n) (ht : ∀ x, P (t + x) = P x) :
    ∀ x, f (t + x) = f t * f x := by
  have hm := hf.1
  have hp := positiveLinearCone_pos hP2 hm
  let C := Real.exp (Real.sqrt (linearLogGradientBound n R) * ‖t‖) + 1
  have hC : 0 < C := by dsimp [C]; positivity
  let g := fun x => C⁻¹ * f (t + x)
  let k := fun x => f x - g x
  have hts : ContDiff ℝ ∞ (fun x => f (t+x)) := hm.1.comp (contDiff_const.add contDiff_id)
  have hgs : ContDiff ℝ ∞ g := contDiff_const.mul hts
  have hks : ContDiff ℝ ∞ k := hm.1.sub hgs
  have hgp (x) : 0 < g x := mul_pos (inv_pos.mpr hC) (hp (t+x))
  have hglt (x) : g x < f x := by
    have H := positive_linear_harnack hm.1 hP hp hR hPb hPd hm.2.2.1 x (t+x)
    simp only [add_sub_cancel_right] at H
    have HH : f (t+x) < C * f x := by dsimp [C]; nlinarith [hp x]
    change C⁻¹ * f (t+x) < f x
    simpa only [div_eq_inv_mul] using (div_lt_iff₀ hC).mpr (by simpa [mul_comm] using HH)
  have hkp (x) : 0 < k x := sub_pos.mpr (hglt x)
  have hgeq (x) : Laplacian.laplacian g x = P x * g x := by
    dsimp only [g]
    rw [laplacian_fun_const_mul (smooth_C2 hts),
      laplacian_translate (smooth_C2 hm.1), hm.2.2.1, ht]
    ring
  have hkeq (x) : Laplacian.laplacian k x = P x * k x := by
    dsimp only [k]
    rw [laplacian_fun_sub (smooth_C2 hm.1) (smooth_C2 hgs), hm.2.2.1, hgeq]
    ring
  have hgmem := positiveLinearCone_normalize hgs (fun x => (hgp x).le) hgeq (hgp 0)
  have hkmem := positiveLinearCone_normalize hks (fun x => (hkp x).le) hkeq (hkp 0)
  have hab : g 0 + k 0 = 1 := by dsimp [k]; rw [hm.2.2.2]; ring
  have hseg : f ∈ openSegment ℝ (fun x => (g 0)⁻¹ * g x) (fun x => (k 0)⁻¹ * k x) := by
    refine ⟨g 0, k 0, hgp 0, hkp 0, hab, ?_⟩
    funext x
    simp only [Pi.add_apply, Pi.smul_apply, smul_eq_mul]
    rw [← mul_assoc, mul_inv_cancel₀ (hgp 0).ne', one_mul,
      ← mul_assoc, mul_inv_cancel₀ (hkp 0).ne', one_mul]
    dsimp [k]; ring
  have hex := hf.2 hgmem hkmem hseg
  intro x
  have H := congrFun hex x
  change (C⁻¹ * f (t + 0))⁻¹ * (C⁻¹ * f (t+x)) = f x at H
  simp only [add_zero] at H
  field_simp [hC.ne', (hp t).ne'] at H
  nlinarith [H]

end DeGiorgi
end

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

lemma positiveLinearCone_extreme_character {n : ℕ} {P f : Space n → ℝ}
    (hP : ContDiff ℝ ∞ P) {R : ℝ} (hR : 0 ≤ R)
    (hPb : ∀ x, |P x| ≤ R) (hPd : ∀ i x, |coordDeriv P i x| ≤ R)
    (hP2 : ∀ x, P x ≤ 2)
    (hf : f ∈ (positiveLinearCone P).extremePoints ℝ)
    (H : Submodule ℝ (Space n)) (hH : ∀ t ∈ H, ∀ x, P (t+x) = P x) :
    ∃ b : H, ∀ (t : H) (x : Space n),
      f ((t : Space n) + x) = Real.exp (inner ℝ b t) * f x := by
  have hp := positiveLinearCone_pos hP2 hf.1
  have htrans (t : H) := positiveLinearCone_extreme_translate hP hR hPb hPd hP2 hf
    (t : Space n) (hH t t.property)
  let L : H →+ ℝ :=
    { toFun := fun t => Real.log (f (t : Space n))
      map_zero' := by simp [hf.1.2.2.2]
      map_add' := by
        intro a b
        change Real.log (f ((a : Space n) + (b : Space n))) = _
        rw [htrans a, Real.log_mul (hp a).ne' (hp b).ne'] }
  have hL : Continuous L :=
    (hf.1.1.continuous.log (fun x => (hp x).ne')).comp continuous_subtype_val
  let l : H →L[ℝ] ℝ := L.toRealLinearMap hL
  let b : H := (InnerProductSpace.toDual ℝ H).symm l
  refine ⟨b, fun t x => ?_⟩
  rw [htrans t]
  congr 1
  have he : inner ℝ b t = Real.log (f (t : Space n)) := by
    exact InnerProductSpace.toDual_symm_apply
  rw [he, Real.exp_log (hp t)]

lemma linear_quotient_drift {n : ℕ} {f u P : Space n → ℝ}
    (hf : ContDiff ℝ ∞ f) (hu : ContDiff ℝ ∞ u) (hp : ∀ x, 0 < f x)
    (heq : ∀ x, Laplacian.laplacian f x = P x * f x) (x : Space n) :
    Laplacian.laplacian (fun y => u y/f y) x -
      fderiv ℝ (fun y => u y/f y) x ((-2:ℝ) • gradient (fun y => Real.log (f y)) x) =
      (Laplacian.laplacian u x-P x*u x)/f x := by
  let q := fun y => u y/f y
  have hq : ContDiff ℝ ∞ q := hu.div hf (fun y => (hp y).ne')
  have hfq : (fun y => q y*f y) = u := by funext y; dsimp [q]; field_simp [(hp y).ne']
  have H := laplacian_fun_mul (smooth_C2 hq) (smooth_C2 hf) x
  rw [hfq, heq x] at H
  rw [gradient_log (hf.differentiable (by simp) x) (hp x).ne', smul_smul,
    map_smul, smul_eq_mul, ← inner_gradient_left]
  change Laplacian.laplacian q x - (-2*(f x)⁻¹)*inner ℝ (gradient q x) (gradient f x) = _
  dsimp [q] at H
  apply (eq_div_iff (hp x).ne').mpr
  have H' := H
  field_simp [ne_of_gt (hp x)] at H' ⊢
  nlinarith

lemma positive_linear_jet_step {n : ℕ} {f u P : Space n → ℝ}
    (hf : ContDiff ℝ ∞ f) (hu : ContDiff ℝ ∞ u) (hp : ∀ x, 0 < f x)
    (heq : ∀ x, Laplacian.laplacian f x = P x*f x)
    {M C L : ℝ} (hM : 0 ≤ M) (hC : 0 ≤ C) (hL : 0 ≤ L)
    (hb : ∀ x, |u x| ≤ M*f x)
    (hPu : ∀ x, |Laplacian.laplacian u x-P x*u x| ≤ C*f x)
    (hlog : ∀ x, ‖gradient (fun y => Real.log (f y)) x‖ ≤ L)
    (i : Fin n) (x : Space n) :
    |coordDeriv u i x| ≤ (2*(2*M+C+3)*(2*L+1)+M*L)*f x := by
  let q := fun y => u y/f y
  have hq : ContDiff ℝ ∞ q := hu.div hf (fun y => (hp y).ne')
  have hqb (y) : |q y| ≤ M := by
    rw [show q y=u y/f y from rfl, abs_div, abs_of_pos (hp y)]
    exact (div_le_iff₀ (hp y)).mpr (hb y)
  have hdb (y) : ‖(-2:ℝ) • gradient (fun z => Real.log (f z)) y‖ ≤ 2*L := by
    simpa only [norm_smul, Real.norm_eq_abs, abs_neg, abs_of_nonneg (by norm_num : (0:ℝ) ≤ 2)] using
      mul_le_mul_of_nonneg_left (hlog y) (by norm_num : (0:ℝ) ≤ 2)
  have hdp (y) : |Laplacian.laplacian q y-fderiv ℝ q y
      ((-2:ℝ) • gradient (fun z => Real.log (f z)) y)| ≤ C := by
    rw [linear_quotient_drift hf hu hp heq, abs_div, abs_of_pos (hp y)]
    exact (div_le_iff₀ (hp y)).mpr (hPu y)
  have H := PoissonSupport.DeGiorgi.bounded_drift_gradient (smooth_C2 hq)
    (fun y => (-2:ℝ) • gradient (fun z => Real.log (f z)) y)
    hM hC (by positivity : 0 ≤ 2*L) hqb hdb hdp x
  have Hqi : |coordDeriv q i x| ≤ 2*(2*M+C+3)*(2*L+1) :=
    (coordDeriv_abs_le_gradient q i x).trans H
  have Hfi : |coordDeriv f i x/f x| ≤ L := by
    rw [← coordDeriv_log (hf.differentiable (by simp)) (fun y => (hp y).ne')]
    exact (coordDeriv_abs_le_gradient _ i x).trans (hlog x)
  have he : coordDeriv u i x =
      (coordDeriv q i x+q x*(coordDeriv f i x/f x))*f x := by
    rw [coordDeriv_div (hu.differentiable (by simp)) (hf.differentiable (by simp))
      (fun y => (hp y).ne')]
    dsimp [q]
    field_simp [ne_of_gt (hp x)]
    ring
  rw [he, abs_mul, abs_of_pos (hp x)]
  apply mul_le_mul_of_nonneg_right _ (hp x).le
  calc |coordDeriv q i x+q x*(coordDeriv f i x/f x)| ≤
      |coordDeriv q i x| + |q x| * |coordDeriv f i x/f x| := by simpa only [abs_mul] using abs_add_le (coordDeriv q i x) (q x*(coordDeriv f i x/f x))
    _ ≤ 2*(2*M+C+3)*(2*L+1)+M*L := add_le_add Hqi (mul_le_mul (hqb x) Hfi (abs_nonneg _) hM)

lemma positiveLinearCone_relative_jets {n : ℕ} {P : Space n → ℝ}
    (hP : ContDiff ℝ ∞ P) {R : ℝ} (hR : 0 ≤ R)
    (hPb : ∀ x, |P x| ≤ R) (hPd : ∀ i x, |coordDeriv P i x| ≤ R)
    (hP2 : ∀ x, P x ≤ 2)
    (hPjets : ∀ l : List (Fin n), ∃ C : ℝ, 0 ≤ C ∧ ∀ x, |coordinateJet P l x| ≤ C) :
    ∀ l : List (Fin n), ∃ M : ℝ, 0 ≤ M ∧ ∀ f ∈ positiveLinearCone P,
      ∀ x, |coordinateJet f l x| ≤ M*f x := by
  have H (k : ℕ) : ∀ l : List (Fin n), l.length ≤ k → ∃ M : ℝ, 0 ≤ M ∧
      ∀ f ∈ positiveLinearCone P, ∀ x, |coordinateJet f l x| ≤ M*f x := by
    induction k with
    | zero =>
      intro l hl
      have he : l=[] := List.length_eq_zero_iff.mp (Nat.eq_zero_of_le_zero hl)
      subst l
      refine ⟨1, by norm_num, ?_⟩
      intro f hf x
      simpa only [coordinateJet, one_mul, abs_of_nonneg (hf.2.1 x)] using (le_rfl : f x ≤ f x)
    | succ k ih =>
      intro l hl
      cases l with
      | nil =>
        refine ⟨1, by norm_num, ?_⟩
        intro f hf x
        simpa only [coordinateJet, one_mul, abs_of_nonneg (hf.2.1 x)] using (le_rfl : f x ≤ f x)
      | cons i l =>
        have hlen : l.length ≤ k := by simpa only [List.length_cons, Nat.add_le_add_iff_right] using hl
        obtain ⟨M,hM,hMb⟩ := ih l hlen
        obtain ⟨C,hC,hCb⟩ := list_relative_sum_bound (jetSplits l)
          (fun p f x => coordinateJet P p.1 x*coordinateJet f p.2 x)
          (fun f x => f x) (positiveLinearCone P) (by
            intro p hp
            obtain ⟨D,hD,hDb⟩ := hPjets p.1
            obtain ⟨N,hN,hNb⟩ := ih p.2 ((jetSplits_length l p hp).2.trans hlen)
            refine ⟨D*N, mul_nonneg hD hN, ?_⟩
            intro f hf x
            rw [abs_mul]
            calc |coordinateJet P p.1 x| * |coordinateJet f p.2 x| ≤ D*(N*f x) :=
                mul_le_mul (hDb x) (hNb f hf x) (abs_nonneg _) hD
              _ = (D*N)*f x := by ring)
        let L := Real.sqrt (linearLogGradientBound n R)
        let C' := C+R*M
        have hC' : 0 ≤ C' := add_nonneg hC (mul_nonneg hR hM)
        refine ⟨2*(2*M+C'+3)*(2*L+1)+M*L, by dsimp [L]; positivity, ?_⟩
        intro f hf x
        have hfp := positiveLinearCone_pos hP2 hf
        have hjet := coordinateJet_smooth hf.1 l
        have hsource (y) : |Laplacian.laplacian (coordinateJet f l) y-P y*coordinateJet f l y| ≤ C'*f y := by
          have he : Laplacian.laplacian f = fun z => P z*f z := funext hf.2.2.1
          rw [coordinateJet_laplacian hf.1 l, he, coordinateJet_mul hP hf.1]
          calc |((jetSplits l).map (fun p => coordinateJet P p.1 y*coordinateJet f p.2 y)).sum -
              P y*coordinateJet f l y| ≤
              |((jetSplits l).map (fun p => coordinateJet P p.1 y*coordinateJet f p.2 y)).sum| +
                |P y| * |coordinateJet f l y| := by simpa only [abs_mul, abs_neg, sub_eq_add_neg] using abs_add_le (((jetSplits l).map (fun p => coordinateJet P p.1 y*coordinateJet f p.2 y)).sum) (-(P y*coordinateJet f l y))
            _ ≤ C*f y+R*(M*f y) := add_le_add (hCb f hf y)
              (mul_le_mul (hPb y) (hMb f hf y) (abs_nonneg _) hR)
            _ = C'*f y := by dsimp [C']; ring
        exact positive_linear_jet_step hf.1 hjet hfp hf.2.2.1 hM hC'
          (Real.sqrt_nonneg _) (hMb f hf) hsource
          (positive_linear_log_gradient hf.1 hP hfp hR hPb hPd hf.2.2.1) i x
  intro l
  exact H l.length l le_rfl

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

def sech (y : ℝ) : ℝ := (Real.cosh y)⁻¹

lemma sech_pos (y : ℝ) : 0 < sech y := inv_pos.mpr (Real.cosh_pos y)

lemma cosh_sq_ge_one (y : ℝ) : 1 ≤ Real.cosh y ^ 2 := by
  nlinarith [Real.cosh_sq_sub_sinh_sq y, sq_nonneg (Real.sinh y)]

lemma contDiff_sech : ContDiff ℝ ∞ sech :=
  Real.contDiff_cosh.inv (fun y => (Real.cosh_pos y).ne')

lemma sech_hasDerivAt (y : ℝ) :
    HasDerivAt sech (-Real.sinh y / Real.cosh y ^ 2) y := by
  exact (Real.hasDerivAt_cosh y).inv (Real.cosh_pos y).ne'

lemma sech_deriv (y : ℝ) : deriv sech y = -Real.sinh y / Real.cosh y ^ 2 :=
  (sech_hasDerivAt y).deriv

lemma sech_hasDerivAt_twice (y : ℝ) :
    HasDerivAt (deriv sech) ((1 - 2 * sech y ^ 2) * sech y) y := by
  have H := ((Real.hasDerivAt_sinh y).neg.div ((Real.hasDerivAt_cosh y).pow 2)
    (pow_ne_zero 2 (Real.cosh_pos y).ne'))
  have he : (-(Real.cosh y) * Real.cosh y ^ 2 - -Real.sinh y *
      (2 * Real.cosh y ^ (2-1) * Real.sinh y)) / (Real.cosh y ^ 2) ^ 2 =
      (1 - 2 * sech y ^ 2) * sech y := by
    dsimp [sech]
    field_simp
    nlinarith [Real.cosh_sq_sub_sinh_sq y]
  change HasDerivAt (fun z => -Real.sinh z / Real.cosh z ^ 2)
    ((-Real.cosh y * Real.cosh y ^ 2 - -Real.sinh y *
      (2 * Real.cosh y ^ (2-1) * Real.sinh y)) / (Real.cosh y ^ 2) ^ 2) y at H
  rw [he] at H
  simpa only [← funext sech_deriv] using H

lemma positive_antitone_flux_zero {w W p : ℝ → ℝ}
    (hw : Differentiable ℝ w) (hwp : ∀ x, 0 < w x)
    (hW : Antitone W) (hp : ∀ x, 1 ≤ p x)
    (heq : ∀ x, deriv w x = W x * p x) : ∀ x, W x = 0 := by
  intro z
  rcases lt_trichotomy (W z) 0 with hz | hz | hz
  · let y := z + (w z + 1) / (-W z)
    have hzy : z ≤ y := by dsimp [y]; exact le_add_of_nonneg_right (div_nonneg (by linarith [hwp z]) (by linarith))
    have hb : ∀ x ∈ interior (Set.Ici z), deriv w x ≤ W z := by
      intro x hx
      have hzx : x ∈ Set.Ici z := interior_subset hx
      rw [heq x]
      have hWx := hW hzx
      calc
        W x * p x ≤ W z * p x := mul_le_mul_of_nonneg_right hWx (by linarith [hp x])
        _ ≤ W z := by nlinarith [hp x]
    have HH := (convex_Ici z).image_sub_le_mul_sub_of_deriv_le
      hw.continuous.continuousOn hw.differentiableOn hb z (by simp) y hzy hzy
    have hm : W z * (y-z) = -(w z + 1) := by dsimp [y]; field_simp [ne_of_lt hz]; ring
    rw [hm] at HH
    linarith [hwp y]
  · exact hz
  · let y := z - (w z + 1) / W z
    have hyz : y ≤ z := by dsimp [y]; exact sub_le_self z (div_nonneg (by linarith [hwp z]) hz.le)
    have hb : ∀ x ∈ interior (Set.Iic z), W z ≤ deriv w x := by
      intro x hx
      have hxz : x ∈ Set.Iic z := interior_subset hx
      rw [heq x]
      have hWx := hW hxz
      calc
        W z ≤ W z * p x := by nlinarith [hp x]
        _ ≤ W x * p x := mul_le_mul_of_nonneg_right hWx (by linarith [hp x])
    have HH := (convex_Iic z).mul_sub_le_image_sub_of_le_deriv
      hw.continuous.continuousOn hw.differentiableOn hb y hyz z (by simp) hyz
    have hm : W z * (z-y) = w z + 1 := by dsimp [y]; field_simp [ne_of_gt hz]; ring
    rw [hm] at HH
    linarith [hwp y]

end DeGiorgi
end

end OAI