import OAI.Analysis.AllenCahn.Modica

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
open scoped ENNReal

def interfaceNormal {n : ℕ} (v : Space n → ℝ) (z : Space n) : Space n :=
  ‖gradient (inverseProfile v) z‖⁻¹ • gradient (inverseProfile v) z

def regularZeroSet {n : ℕ} (v : Space n → ℝ) : Set (Space n) :=
  {z | v z=0 ∧ gradient (inverseProfile v) z≠0}

def chordDirection {n : ℕ} (z y : Space n) : Space n := ‖y-z‖⁻¹ • (y-z)

def chordAngle {n : ℕ} (v : Space n → ℝ) (z y : Space n) : ℝ :=
  |inner ℝ (interfaceNormal v z) (chordDirection z y)|

def reachChordValue {n : ℕ} (Γ : ℝ → ℝ) (v : Space n → ℝ) (z y : Space n) : ℝ≥0∞ :=
  if y=z ∨ chordAngle v z y=0 then ⊤
  else ENNReal.ofReal (‖y-z‖*Γ (chordAngle v z y))

def penalizedReach {n : ℕ} (Γ : ℝ → ℝ) (v : Space n → ℝ) (z : Space n) : ℝ≥0∞ :=
  ⨅ y : {y : Space n // v y=0}, reachChordValue Γ v z y

def OffDiagonalActive {n : ℕ} (Γ : ℝ → ℝ) (v : Space n → ℝ) (z y : Space n) : Prop :=
  z∈regularZeroSet v ∧ v y=0 ∧ y≠z ∧ 0<chordAngle v z y ∧
    reachChordValue Γ v z y=penalizedReach Γ v z

lemma interfaceNormal_norm {n : ℕ} {v : Space n → ℝ} {z : Space n}
    (hz : z∈regularZeroSet v) : ‖interfaceNormal v z‖=1 := by
  rw [interfaceNormal,norm_smul,Real.norm_eq_abs,abs_inv,
    abs_of_nonneg (norm_nonneg _),inv_mul_cancel₀ (norm_ne_zero_iff.mpr hz.2)]

lemma chordDirection_norm {n : ℕ} {z y : Space n} (h : y≠z) :
    ‖chordDirection z y‖=1 := by
  rw [chordDirection,norm_smul,Real.norm_eq_abs,abs_inv,
    abs_of_nonneg (norm_nonneg _),inv_mul_cancel₀ (norm_ne_zero_iff.mpr (sub_ne_zero.mpr h))]

lemma chordAngle_le_one {n : ℕ} {v : Space n → ℝ} {z y : Space n}
    (hz : z∈regularZeroSet v) (hy : y≠z) : chordAngle v z y≤1 := by
  have H := abs_real_inner_le_norm (interfaceNormal v z) (chordDirection z y)
  simpa only [interfaceNormal_norm hz,chordDirection_norm hy,mul_one,chordAngle] using H

lemma chord_backwards {n : ℕ} (y N : Space n) (hN : ‖N‖=1) {s t : ℝ} (hst : s<t) :
    ‖(y+s•N)-(y+t•N)‖=t-s ∧
      chordDirection (y+t•N) (y+s•N)= -N := by
  have he : (y+s•N)-(y+t•N)=(s-t)•N := by module
  have hnorm : ‖(y+s•N)-(y+t•N)‖=t-s := by
    rw [he,norm_smul,Real.norm_eq_abs,abs_of_neg (sub_neg.mpr hst),hN,mul_one]
    ring
  refine ⟨hnorm,?_⟩
  rw [chordDirection,hnorm,he,smul_smul]
  have hc : (t-s)⁻¹*(s-t)= -1 := by
    field_simp [ne_of_gt (sub_pos.mpr hst)]
    ring
  rw [hc,neg_one_smul]

lemma active_contact_no_nearer_zero_on_ray {n : ℕ} {v : Space n → ℝ} {Γ : ℝ → ℝ}
    (hΓ : ∀ s, 0<s → s≤1 → s⁻¹≤Γ s)
    {y N : Space n} (hN : ‖N‖=1) {s t : ℝ} (hs : 0<s) (hst : s<t)
    (hactive : OffDiagonalActive Γ v (y+t•N) y) : v (y+s•N)≠0 := by
  intro hzero
  have ht : 0<t := hs.trans hst
  obtain ⟨hr,hy,hyne,ha,hact⟩ := hactive
  have hany := iInf_le (fun z : {z : Space n // v z=0} =>
    reachChordValue Γ v (y+t•N) z) ⟨y+s•N,hzero⟩
  change penalizedReach Γ v (y+t•N) ≤ reachChordValue Γ v (y+t•N) (y+s•N) at hany
  rw [← hact] at hany
  obtain ⟨hnorm1,hdir1⟩ := chord_backwards y N hN hst
  obtain ⟨hnorm0,hdir0⟩ := chord_backwards y N hN (s:=0) ht
  simp only [zero_smul,add_zero,sub_zero] at hnorm0 hdir0
  have hangle : chordAngle v (y+t•N) (y+s•N)=chordAngle v (y+t•N) y := by
    simp only [chordAngle,hdir1,hdir0]
  have hne : y+s•N≠y+t•N := by
    intro he
    have hh : ‖(y+s•N)-(y+t•N)‖=0 := by rw [he,sub_self,norm_zero]
    linarith
  have hg : 0<Γ (chordAngle v (y+t•N) y) :=
    lt_of_lt_of_le (inv_pos.mpr ha) (hΓ _ ha (chordAngle_le_one hr hyne))
  simp only [reachChordValue,hyne,ha.ne',or_self,ite_false,hne,hangle,hnorm0,hnorm1] at hany
  have hstrict : ENNReal.ofReal ((t-s)*Γ (chordAngle v (y+t•N) y)) <
      ENNReal.ofReal (t*Γ (chordAngle v (y+t•N) y)) := by
    apply ENNReal.ofReal_lt_ofReal_iff'.mpr
    constructor <;> nlinarith
  exact not_lt_of_ge hany hstrict

lemma active_bases_on_ray_unique {n : ℕ} {v : Space n → ℝ} {Γ : ℝ → ℝ}
    (hΓ : ∀ a, 0<a → a≤1 → a⁻¹≤Γ a)
    {y N : Space n} (hN : ‖N‖=1) {s t : ℝ} (hs : 0<s) (ht : 0<t)
    (hsact : OffDiagonalActive Γ v (y+s•N) y)
    (htact : OffDiagonalActive Γ v (y+t•N) y) : s=t := by
  rcases lt_trichotomy s t with h|h|h
  · exact False.elim ((active_contact_no_nearer_zero_on_ray hΓ hN hs h htact) hsact.1.1)
  · exact h
  · exact False.elim ((active_contact_no_nearer_zero_on_ray hΓ hN ht h hsact) htact.1.1)

lemma active_ray_subsingleton {n : ℕ} {v : Space n → ℝ} {Γ : ℝ → ℝ}
    (hΓ : ∀ a, 0<a → a≤1 → a⁻¹≤Γ a) {y N : Space n} (hN : ‖N‖=1) :
    Set.Subsingleton {z | ∃ t : ℝ, 0<t ∧ z=y+t•N ∧ OffDiagonalActive Γ v z y} := by
  rintro z ⟨s,hs,rfl,has⟩ w ⟨t,ht,rfl,hat⟩
  rw [active_bases_on_ray_unique hΓ hN hs ht has hat]

lemma chordAngle_mul_length {n : ℕ} (v : Space n → ℝ) {z y : Space n} (hy : y≠z) :
    chordAngle v z y*‖y-z‖=|inner ℝ (interfaceNormal v z) (y-z)| := by
  have hl : ‖y-z‖≠0 := norm_ne_zero_iff.mpr (sub_ne_zero.mpr hy)
  simp only [chordAngle,chordDirection,inner_smul_right,abs_mul,abs_inv,
    abs_of_nonneg (norm_nonneg _)]
  field_simp

lemma reach_chord_inequality {n : ℕ} {v : Space n → ℝ} {Γ : ℝ → ℝ} {C : ℝ}
    (hC : 0<C) (hΓ0 : ∀ s, 0<s → s≤1 → 0≤Γ s)
    (hΓ : ∀ s, 0<s → s≤1 → Γ s≤C/s)
    {z : Space n} (hz : z∈regularZeroSet v) {y : Space n} (hy : v y=0) :
    (penalizedReach Γ v z).toReal*|inner ℝ (interfaceNormal v z) (y-z)|≤C*‖y-z‖^2 := by
  by_cases hyz : y=z
  · subst y
    simp
  have hl : 0<‖y-z‖ := norm_pos_iff.mpr (sub_ne_zero.mpr hyz)
  have ha0 : 0≤chordAngle v z y := abs_nonneg _
  have ha1 := chordAngle_le_one hz hyz
  have halink := chordAngle_mul_length v hyz
  by_cases ha : chordAngle v z y=0
  · rw [ha,zero_mul] at halink
    rw [←halink,mul_zero]
    positivity
  have hap : 0<chordAngle v z y := lt_of_le_of_ne ha0 (Ne.symm ha)
  have hg0 := hΓ0 _ hap ha1
  have hi := iInf_le (fun w : {w : Space n // v w=0}=>reachChordValue Γ v z w) ⟨y,hy⟩
  change penalizedReach Γ v z≤reachChordValue Γ v z y at hi
  simp only [reachChordValue,hyz,ha,or_self,ite_false] at hi
  have hir := ENNReal.toReal_mono (by exact ENNReal.ofReal_ne_top) hi
  rw [ENNReal.toReal_ofReal (mul_nonneg hl.le hg0)] at hir
  have hg := (le_div_iff₀ hap).mp (hΓ _ hap ha1)
  have hh : (penalizedReach Γ v z).toReal*chordAngle v z y≤C*‖y-z‖ := by
    calc
      _ ≤ (‖y-z‖*Γ (chordAngle v z y))*chordAngle v z y :=
        mul_le_mul_of_nonneg_right hir hap.le
      _ = ‖y-z‖*(Γ (chordAngle v z y)*chordAngle v z y) := by ring
      _ ≤ ‖y-z‖*C := mul_le_mul_of_nonneg_left hg hl.le
      _ = _ := by ring
  have hh' := mul_le_mul_of_nonneg_right hh hl.le
  rw [mul_assoc,halink] at hh'
  nlinarith [hh']

lemma reach_tangent_ball_zero_free {n : ℕ} {v : Space n → ℝ} {Γ : ℝ → ℝ} {C : ℝ}
    (hC : 0<C) (hΓ0 : ∀ s, 0<s → s≤1 → 0≤Γ s)
    (hΓ : ∀ s, 0<s → s≤1 → Γ s≤C/s)
    {z : Space n} (hz : z∈regularZeroSet v) {r : ℝ} (hr : 0<r)
    (hd : 2*C*r≤(penalizedReach Γ v z).toReal) {σ : ℝ} (hσ : |σ|=1) :
    ∀ x∈Metric.ball (z+(σ*r)•interfaceNormal v z) r, v x≠0 := by
  intro x hx hvx
  have hn := interfaceNormal_norm hz
  have hs : σ^2=1 := by nlinarith [sq_abs σ]
  have hball := Metric.mem_ball.mp hx
  rw [dist_eq_norm] at hball
  have hsq : ‖x-(z+(σ*r)•interfaceNormal v z)‖^2<r^2 :=
    sq_lt_sq₀ (norm_nonneg _) hr.le |>.mpr hball
  have he : x-(z+(σ*r)•interfaceNormal v z)=(x-z)-(σ*r)•interfaceNormal v z := by module
  rw [he,norm_sub_sq_real,norm_smul,Real.norm_eq_abs,abs_mul,hσ,one_mul,abs_of_pos hr,
    hn,mul_one,inner_smul_right] at hsq
  have hins : inner ℝ (x-z) (interfaceNormal v z)=inner ℝ (interfaceNormal v z) (x-z) :=
    real_inner_comm _ _
  rw [hins] at hsq
  have hinner : σ*inner ℝ (interfaceNormal v z) (x-z)≤
      |inner ℝ (interfaceNormal v z) (x-z)| := by
    calc
      _ ≤ |σ*inner ℝ (interfaceNormal v z) (x-z)| := le_abs_self _
      _ = _ := by rw [abs_mul,hσ,one_mul]
  have hc := reach_chord_inequality hC hΓ0 hΓ hz hvx
  have hmul := mul_le_mul_of_nonneg_right hd (abs_nonneg (inner ℝ (interfaceNormal v z) (x-z)))
  have hstrict : ‖x-z‖^2<2*r*|inner ℝ (interfaceNormal v z) (x-z)| := by
    nlinarith [mul_le_mul_of_nonneg_left hinner (by positivity : 0≤2*r)]
  have hstrictC := mul_lt_mul_of_pos_left hstrict hC
  nlinarith

lemma penalized_normal_map_injective {n : ℕ} {v : Space n → ℝ} {Γ : ℝ → ℝ} {C : ℝ}
    (hC : 0<C) (hΓ0 : ∀ a, 0<a → a≤1 → 0≤Γ a)
    (hΓ : ∀ a, 0<a → a≤1 → Γ a≤C/a)
    {z w : Space n} (hz : z∈regularZeroSet v) (hw : w∈regularZeroSet v)
    {t s : ℝ} (ht : 4*C*|t|≤(penalizedReach Γ v z).toReal)
    (hs : 4*C*|s|≤(penalizedReach Γ v w).toReal)
    (heq : z+t•interfaceNormal v z=w+s•interfaceNormal v w) : z=w ∧ t=s := by
  have hzch := reach_chord_inequality hC hΓ0 hΓ hz hw.1
  have hwch := reach_chord_inequality hC hΓ0 hΓ hw hz.1
  have hneg : z-w= -(w-z) := by module
  rw [hneg,norm_neg,inner_neg_right,abs_neg] at hwch
  have hzt := mul_le_mul_of_nonneg_right ht
    (abs_nonneg (inner ℝ (interfaceNormal v z) (w-z)))
  have hws := mul_le_mul_of_nonneg_right hs
    (abs_nonneg (inner ℝ (interfaceNormal v w) (w-z)))
  have hza : 4*|t| * |inner ℝ (interfaceNormal v z) (w-z)|≤‖w-z‖^2 := by
    have H := hzt.trans hzch
    nlinarith
  have hwa : 4*|s| * |inner ℝ (interfaceNormal v w) (w-z)|≤‖w-z‖^2 := by
    have H := hws.trans hwch
    nlinarith
  have hd : w-z=t•interfaceNormal v z-s•interfaceNormal v w := by
    calc
      _ = (w+s•interfaceNormal v w)-(z+s•interfaceNormal v w) := by module
      _ = _ := by rw [←heq]; module
  have hi : ‖w-z‖^2=t*inner ℝ (interfaceNormal v z) (w-z)-
      s*inner ℝ (interfaceNormal v w) (w-z) := by
    rw [← real_inner_self_eq_norm_sq]
    nth_rw 1 [hd]
    simp only [inner_sub_left,real_inner_smul_left]
  have hti : t*inner ℝ (interfaceNormal v z) (w-z)≤
      |t| * |inner ℝ (interfaceNormal v z) (w-z)| := by
    simpa only [abs_mul] using (le_abs_self (t*inner ℝ (interfaceNormal v z) (w-z)))
  have hsi : -(s*inner ℝ (interfaceNormal v w) (w-z))≤
      |s| * |inner ℝ (interfaceNormal v w) (w-z)| := by
    simpa only [abs_mul] using (neg_le_abs (s*inner ℝ (interfaceNormal v w) (w-z)))
  have hn : ‖w-z‖=0 := by nlinarith [norm_nonneg (w-z)]
  have hzw : z=w := (sub_eq_zero.mp (norm_eq_zero.mp hn)).symm
  refine ⟨hzw,?_⟩
  subst w
  have he : (t-s)•interfaceNormal v z=0 := by
    have hh := add_left_cancel heq
    rw [sub_smul,hh,sub_self]
  have hh := congrArg norm he
  rw [norm_smul,Real.norm_eq_abs,interfaceNormal_norm hz,mul_one,norm_zero] at hh
  exact sub_eq_zero.mp (abs_eq_zero.mp hh)

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
open scoped ENNReal

lemma quadratic_residual_of_lipschitz_fderiv {n : ℕ} {f : Space n → ℝ}
    (hf : Differentiable ℝ f) {K : NNReal} {z y : Space n} {r : ℝ} (hr : 0<r)
    (hL : LipschitzOnWith K (fderiv ℝ f) (Metric.ball z r))
    (hy : y∈Metric.ball z r) :
    |f y-f z-fderiv ℝ f z (y-z)|≤(K:ℝ)*‖y-z‖^2 := by
  let g : Space n → ℝ := fun x=>f x-fderiv ℝ f z (x-z)
  have hd (x : Space n) : HasFDerivAt g (fderiv ℝ f x-fderiv ℝ f z) x := by
    exact (hf x).hasFDerivAt.sub ((fderiv ℝ f z).hasFDerivAt.comp x (hasFDerivAt_id x |>.sub_const z))
  have hsub : Metric.closedBall z ‖y-z‖ ⊆ Metric.ball z r := by
    intro x hx
    apply Metric.mem_ball.mpr
    exact (Metric.mem_closedBall.mp hx).trans_lt (by simpa [dist_eq_norm] using hy)
  have hb (x : Space n) (hx : x∈Metric.closedBall z ‖y-z‖) :
      ‖fderiv ℝ f x-fderiv ℝ f z‖≤(K:ℝ)*‖y-z‖ := by
    calc
      _ ≤ (K:ℝ)*‖x-z‖ := hL.norm_sub_le (hsub hx) (Metric.mem_ball_self hr)
      _ ≤ _ := mul_le_mul_of_nonneg_left (by simpa [dist_eq_norm] using hx) K.coe_nonneg
  have H := (convex_closedBall z ‖y-z‖).norm_image_sub_le_of_norm_hasFDerivWithin_le
    (fun x _=>(hd x).hasFDerivWithinAt) hb (Metric.mem_closedBall_self (norm_nonneg _))
    (by simp [Metric.mem_closedBall,dist_eq_norm] : y∈Metric.closedBall z ‖y-z‖)
  have he : g y-g z=f y-f z-fderiv ℝ f z (y-z) := by
    dsimp [g]
    simp only [sub_self,map_zero,sub_zero]
    ring
  rw [he,Real.norm_eq_abs] at H
  convert H using 1
  ring

lemma regular_zero_local_chord_bound {n : ℕ} {v : Space n → ℝ}
    (hU : ContDiff ℝ 2 (inverseProfile v)) {z : Space n} (hz : z∈regularZeroSet v) :
    ∃ r B : ℝ, 0<r ∧ 0<B ∧ ∀ y∈Metric.ball z r, v y=0 →
      |inner ℝ (interfaceNormal v z) (y-z)|≤B*‖y-z‖^2 := by
  have hU1 : ContDiff ℝ 1 (fderiv ℝ (inverseProfile v)) := hU.fderiv_right (by norm_num)
  obtain ⟨K,t,ht,hK⟩ := hU1.contDiffAt (x:=z) |>.exists_lipschitzOnWith
  obtain ⟨r,hr,hrt⟩ := Metric.mem_nhds_iff.mp ht
  have hgrad : 0<‖gradient (inverseProfile v) z‖ := norm_pos_iff.mpr hz.2
  refine ⟨r,((K:ℝ)+1)/‖gradient (inverseProfile v) z‖,hr,by positivity,?_⟩
  intro y hy hvy
  have H := quadratic_residual_of_lipschitz_fderiv (hU.differentiable (by norm_num)) hr (hK.mono hrt) hy
  have hUz : inverseProfile v z=0 := by simp [inverseProfile,hz.1]
  have hUy : inverseProfile v y=0 := by simp [inverseProfile,hvy]
  rw [hUy,hUz,sub_self,zero_sub,abs_neg] at H
  have he : |inner ℝ (interfaceNormal v z) (y-z)|=
      |fderiv ℝ (inverseProfile v) z (y-z)|/‖gradient (inverseProfile v) z‖ := by
    simp [interfaceNormal,real_inner_smul_left,inner_gradient_left,abs_mul,abs_inv,
      abs_of_pos hgrad,div_eq_mul_inv,mul_comm]
  rw [he]
  apply (div_le_div_of_nonneg_right H hgrad.le).trans
  have hh : (K:ℝ)*‖y-z‖^2≤((K:ℝ)+1)*‖y-z‖^2 := by nlinarith [sq_nonneg ‖y-z‖]
  simpa [div_mul_eq_mul_div] using div_le_div_of_nonneg_right hh hgrad.le

lemma penalizedReach_pos {n : ℕ} {v : Space n → ℝ} {Γ : ℝ → ℝ}
    (hU : ContDiff ℝ 2 (inverseProfile v))
    (hΓ : ∀ a, 0<a → a≤1 → a⁻¹≤Γ a)
    {z : Space n} (hz : z∈regularZeroSet v) : 0<penalizedReach Γ v z := by
  obtain ⟨r,B,hr,hB,hbound⟩ := regular_zero_local_chord_bound hU hz
  let c := min r B⁻¹
  have hc : 0<c := lt_min hr (inv_pos.mpr hB)
  have H : ENNReal.ofReal c ≤ penalizedReach Γ v z := by
    apply le_iInf
    rintro ⟨y,hy⟩
    change ENNReal.ofReal c≤reachChordValue Γ v z y
    by_cases hi : y=z ∨ chordAngle v z y=0
    · simp [reachChordValue,hi]
    simp only [reachChordValue,hi,ite_false]
    apply ENNReal.ofReal_le_ofReal
    have hyz : y≠z := fun hh=>hi (Or.inl hh)
    have ha : 0<chordAngle v z y :=
      lt_of_le_of_ne (abs_nonneg _) (Ne.symm (fun hh=>hi (Or.inr hh)))
    have ha1 := chordAngle_le_one hz hyz
    have hΓ1 : 1≤Γ (chordAngle v z y) :=
      (one_le_inv₀ ha |>.mpr ha1).trans (hΓ _ ha ha1)
    have hl : 0<‖y-z‖ := norm_pos_iff.mpr (sub_ne_zero.mpr hyz)
    by_cases hyr : y∈Metric.ball z r
    · have hb := hbound y hyr hy
      rw [←chordAngle_mul_length v hyz] at hb
      have hab : chordAngle v z y≤B*‖y-z‖ := by nlinarith
      have hg := hΓ _ ha ha1
      have hg' : 1≤Γ (chordAngle v z y)*chordAngle v z y := by
        have := mul_le_mul_of_nonneg_right hg ha.le
        simpa [ne_of_gt ha] using this
      have hprod : 1≤B*(‖y-z‖*Γ (chordAngle v z y)) := by
        have hh := mul_le_mul_of_nonneg_left hab (zero_le_one.trans hΓ1)
        nlinarith
      have hcost : B⁻¹≤‖y-z‖*Γ (chordAngle v z y) := by
        rw [inv_eq_one_div]
        exact (div_le_iff₀ hB).mpr (by simpa [mul_comm] using hprod)
      exact (min_le_right _ _).trans hcost
    · have hr' : r≤‖y-z‖ := by simpa [Metric.mem_ball,dist_eq_norm] using hyr
      exact (min_le_left _ _).trans (hr'.trans (by nlinarith [mul_le_mul_of_nonneg_left hΓ1 hl.le]))
  exact ENNReal.ofReal_pos.mpr hc |>.trans_le H

lemma chordAngle_continuousAt {n : ℕ} (v : Space n → ℝ) {z y : Space n}
    (hy : y≠z) : ContinuousAt (chordAngle v z) y := by
  unfold chordAngle chordDirection
  exact (continuousAt_const.inner
    (((continuousAt_id.sub continuousAt_const).norm.inv₀
      (norm_ne_zero_iff.mpr (sub_ne_zero.mpr hy))).smul
      (continuousAt_id.sub continuousAt_const))).abs

end DeGiorgi
end

end OAI