import OAI.Analysis.IntegralMeans.CriticalMap

namespace OAI

noncomputable section
open Set MeasureTheory Filter Function InnerProductSpace
open scoped Topology ComplexConjugate Manifold NNReal ENNReal InnerProductSpace Classical
open MeasureTheory Function
open Set Filter
open Set MeasureTheory Filter Function
open Set MeasureTheory Filter Function InnerProductSpace
open TopologicalSpace
open scoped CompactlySupported
open scoped ENNReal
open scoped Manifold
open scoped Topology CompactlySupported ComplexConjugate
open scoped Topology ComplexConjugate Manifold NNReal ENNReal InnerProductSpace Classical
open scoped Topology ENNReal NNReal
namespace Brennan

lemma second_derivative_nonneg_at_min_zero {f f' : ℝ → ℝ} {b : ℝ}
    (hmin : IsLocalMin f 0) (hf : ∀ᶠ x in 𝓝 0, HasDerivAt f (f' x) x)
    (hf' : HasDerivAt f' b 0) : 0 ≤ b := by
  by_contra hb
  have hb : b < 0 := lt_of_not_ge hb
  have hzero : f' 0 = 0 := hmin.hasDerivAt_eq_zero hf.self_of_nhds
  have hrem := (hasDerivAt_iff_isLittleO_nhds_zero.mp hf').bound
    (by linarith : 0 < -b/2)
  have he : ∀ᶠ x in 𝓝 (0 : ℝ),
      HasDerivAt f (f' x) x ∧ f 0 ≤ f x ∧ |f' x - x*b| ≤ (-b/2)*|x| := by
    filter_upwards [hf,hmin,hrem] with x hdx hmx hrx
    exact ⟨hdx,hmx,by simpa [hzero,Real.norm_eq_abs] using hrx⟩
  obtain ⟨δ,hδ,hall⟩ := Metric.eventually_nhds_iff.mp he
  have hball {x : ℝ} (hx : x ∈ Icc 0 (δ/2)) : dist x 0 < δ := by
    rw [Real.dist_eq, sub_zero, abs_of_nonneg hx.1]
    linarith [hx.2]
  have hc : ContinuousOn f (Icc 0 (δ/2)) := by
    intro x hx
    exact (hall (hball hx)).1.continuousAt.continuousWithinAt
  obtain ⟨c,hcint,hceq⟩ := exists_deriv_eq_slope f (by linarith : 0 < δ/2) hc
    (fun x hx => (hall (hball (Ioo_subset_Icc_self hx))).1.differentiableAt.differentiableWithinAt)
  have hcl := hall (hball (Ioo_subset_Icc_self hcint))
  rw [hcl.1.deriv] at hceq
  have hend := (hall (hball (show δ/2 ∈ Icc 0 (δ/2) by constructor <;> linarith))).2.1
  have hf'c : 0 ≤ f' c := by
    rw [hceq]
    exact div_nonneg (sub_nonneg.mpr hend) (by linarith)
  have hupper := (le_abs_self (f' c-c*b)).trans hcl.2.2
  rw [abs_of_pos hcint.1] at hupper
  nlinarith [mul_neg_of_pos_of_neg hcint.1 hb]

lemma second_directional_nonneg_at_min {u : ℂ → ℝ} {z v : ℂ}
    (hmin : IsLocalMin u z)
    (hu : ∀ᶠ w in 𝓝 z, DifferentiableAt ℝ u w)
    (hv : DifferentiableAt ℝ (fun w => fderiv ℝ u w v) z) :
    0 ≤ fderiv ℝ (fun w => fderiv ℝ u w v) z v := by
  let g : ℝ → ℂ := fun t => z + t • v
  have hg (t : ℝ) : HasDerivAt g v t := by
    simpa [g] using (hasDerivAt_id t).smul_const v |>.const_add z
  have hgz : g 0 = z := by simp [g]
  have hmin' : IsLocalMin (u ∘ g) 0 :=
    (hgz ▸ hmin).comp_continuous (hg 0).continuousAt
  have hu' : ∀ᶠ t in 𝓝 (0 : ℝ), HasDerivAt (u ∘ g) (fderiv ℝ u (g t) v) t := by
    have ht : Tendsto g (𝓝 0) (𝓝 z) := hgz ▸ (hg 0).continuousAt
    filter_upwards [ht.eventually hu] with t ht
    exact ht.hasFDerivAt.comp_hasDerivAt t (hg t)
  have hv' : HasDerivAt (fun t => fderiv ℝ u (g t) v)
      (fderiv ℝ (fun w => fderiv ℝ u w v) z v) 0 := by
    exact (hv.hasFDerivAt.comp_hasDerivAt_of_eq 0 (hg 0) hgz.symm)
  exact second_derivative_nonneg_at_min_zero hmin' hu' hv'

lemma differentiableAt_fderiv_logPotential_apply {f : ℂ → ℂ}
    (hf : UnivalentOn f halfPlane) {z ξ : ℂ} (hz : z ∈ halfPlane)
    (hp : f z ≠ ξ) (k : ℝ) (v : ℂ) :
    DifferentiableAt ℝ (fun w => fderiv ℝ (logPotential f k ξ) w v) z := by
  have hd := (hf.1 z hz).differentiableAt (isOpen_halfPlane.mem_nhds hz)
  have hn := hd.continuousAt.eventually_ne hp
  have heq : (fun w => fderiv ℝ (logPotential f k ξ) w v) =ᶠ[𝓝 z]
      (fun w => k / w.im * v.im - (targetRatio f ξ w * v).re) := by
    filter_upwards [isOpen_halfPlane.mem_nhds hz, hn] with w hw hne
    rw [fderiv_logPotential_apply hf hw hne]
    unfold targetRatio
    congr 2
    ring
  have ha : DifferentiableAt ℝ (fun w : ℂ => k / w.im * v.im) z := by
    have hi := (hasDerivAt_inv (ne_of_gt hz)).differentiableAt.comp z
      Complex.imCLM.differentiableAt
    simpa only [div_eq_mul_inv, Function.comp_def, Complex.imCLM_apply] using
      (hi.const_mul k).mul_const v.im
  have hb : DifferentiableAt ℝ (fun w => (targetRatio f ξ w * v).re) z :=
    Complex.reCLM.differentiableAt.comp z
      (((hasDerivAt_targetRatio hf hz hp).differentiableAt.restrictScalars ℝ).mul_const v)
  exact (ha.sub hb).congr_of_eventuallyEq heq

lemma not_isLocalMin_logPotential {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {k : ℝ} (hk : 0 < k) {z ξ : ℂ} (hz : z ∈ halfPlane) (hp : f z ≠ ξ) :
    ¬ IsLocalMin (logPotential f k ξ) z := by
  intro hmin
  have hd := (hf.1 z hz).differentiableAt (isOpen_halfPlane.mem_nhds hz)
  have hu : ∀ᶠ w in 𝓝 z, DifferentiableAt ℝ (logPotential f k ξ) w := by
    filter_upwards [isOpen_halfPlane.mem_nhds hz, hd.continuousAt.eventually_ne hp]
      with w hw hne
    exact differentiableAt_logPotential hf hw hne k
  have h1 := second_directional_nonneg_at_min hmin hu
    (differentiableAt_fderiv_logPotential_apply hf hz hp k 1)
  have hI := second_directional_nonneg_at_min hmin hu
    (differentiableAt_fderiv_logPotential_apply hf hz hp k Complex.I)
  have ht := trace_realHessian_negative hf hk hz hp
  simp only [realHessian, Matrix.trace, Matrix.diag, Fin.sum_univ_two,
    Matrix.of_apply, Matrix.cons_val_zero, Matrix.cons_val_one] at ht
  change secondDirectional _ z 1 1 + secondDirectional _ z Complex.I Complex.I < 0 at ht
  unfold secondDirectional at ht
  linarith

def reciprocalPotential (f : ℂ → ℂ) (k : ℝ) (ξ z : ℂ) : ℝ :=
  ‖f z-ξ‖ / z.im^k

lemma continuousOn_reciprocalPotential {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    (k : ℝ) (ξ : ℂ) : ContinuousOn (reciprocalPotential f k ξ) halfPlane := by
  apply ((hf.1.continuousOn.sub continuousOn_const).norm).div
    (Complex.continuous_im.continuousOn.rpow_const (fun z hz => Or.inl (ne_of_gt hz)))
  intro z hz
  exact ne_of_gt (Real.rpow_pos_of_pos hz k)

lemma reciprocalPotential_pos {f : ℂ → ℂ} {k : ℝ} {ξ z : ℂ}
    (hz : z ∈ halfPlane) (hp : f z ≠ ξ) : 0 < reciprocalPotential f k ξ z := by
  exact div_pos (norm_pos_iff.mpr (sub_ne_zero.mpr hp)) (Real.rpow_pos_of_pos hz k)

lemma log_reciprocalPotential {f : ℂ → ℂ} {k : ℝ} {ξ z : ℂ}
    (hz : z ∈ halfPlane) (hp : f z ≠ ξ) :
    Real.log (reciprocalPotential f k ξ z) = -logPotential f k ξ z := by
  rw [reciprocalPotential,Real.log_div (norm_ne_zero_iff.mpr (sub_ne_zero.mpr hp))
    (ne_of_gt (Real.rpow_pos_of_pos hz k)),Real.log_rpow hz,logPotential]
  ring

lemma not_isLocalMax_reciprocalPotential {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {k : ℝ} (hk : 0 < k) {z ξ : ℂ} (hz : z ∈ halfPlane) (hp : f z ≠ ξ) :
    ¬ IsLocalMax (reciprocalPotential f k ξ) z := by
  intro hmax
  apply not_isLocalMin_logPotential hf hk hz hp
  have hd := (hf.1 z hz).differentiableAt (isOpen_halfPlane.mem_nhds hz)
  filter_upwards [hmax,isOpen_halfPlane.mem_nhds hz,hd.continuousAt.eventually_ne hp]
    with w hw hwH hwne
  have hl := Real.log_le_log (reciprocalPotential_pos hwH hwne) hw
  rw [log_reciprocalPotential hwH hwne,log_reciprocalPotential hz hp] at hl
  linarith

lemma reciprocalPotential_lt_boundary {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {k b : ℝ} (hk : 0 < k) (hb : 0 < b) (ξ : ℂ) {U : Set ℂ}
    (ho : IsOpen U) (hcompact : IsCompact (closure U))
    (hH : closure U ⊆ halfPlane)
    (hboundary : ∀ z ∈ frontier U, reciprocalPotential f k ξ z ≤ b)
    {z : ℂ} (hz : z ∈ U) : reciprocalPotential f k ξ z < b := by
  have hcont := (continuousOn_reciprocalPotential hf k ξ).mono hH
  obtain ⟨a,ha,hmax⟩ := hcompact.exists_isMaxOn ⟨z,subset_closure hz⟩ hcont
  have hmaxle : reciprocalPotential f k ξ a ≤ b := by
    by_contra hn
    have hab : b < reciprocalPotential f k ξ a := lt_of_not_ge hn
    have haU : a ∈ U := by
      by_contra hau
      have haf : a ∈ frontier U := ⟨ha,by simpa only [ho.interior_eq] using hau⟩
      exact (not_lt_of_ge (hboundary a haf)) hab
    have hane : f a ≠ ξ := by
      intro he
      have he0 : reciprocalPotential f k ξ a = 0 := by simp [reciprocalPotential,he]
      linarith
    exact not_isLocalMax_reciprocalPotential hf hk (hH ha) hane
      (hmax.isLocalMax (mem_of_superset (ho.mem_nhds haU) subset_closure))
  have hwhole : ∀ w ∈ closure U, reciprocalPotential f k ξ w ≤ b :=
    fun w hw => (hmax hw).trans hmaxle
  have hzle := hwhole z (subset_closure hz)
  apply lt_of_le_of_ne hzle
  intro he
  have hzne : f z ≠ ξ := by
    intro hze
    have he0 : reciprocalPotential f k ξ z = 0 := by simp [reciprocalPotential,hze]
    linarith
  apply not_isLocalMax_reciprocalPotential hf hk (hH (subset_closure hz)) hzne
  filter_upwards [ho.mem_nhds hz] with w hw
  exact (hwhole w (subset_closure hw)).trans_eq he.symm

def regularizedGradient (f : ℂ → ℂ) (k : ℝ) (ξ z : ℂ) : ℂ :=
  ((k : ℂ)*Complex.I/(z.im : ℂ))*(f z-ξ)*conj (criticalMap f k z-ξ)

lemma regularizedGradient_eq_zero_iff {f : ℂ → ℂ} {k : ℝ} (hk : k ≠ 0)
    {ξ z : ℂ} (hz : z ∈ halfPlane) :
    regularizedGradient f k ξ z = 0 ↔ f z = ξ ∨ criticalMap f k z = ξ := by
  have hc : ((k : ℂ)*Complex.I/(z.im : ℂ)) ≠ 0 := div_ne_zero
    (mul_ne_zero (Complex.ofReal_ne_zero.mpr hk) Complex.I_ne_zero)
    (Complex.ofReal_ne_zero.mpr (ne_of_gt hz))
  simp only [regularizedGradient,mul_eq_zero,hc,false_or,sub_eq_zero,map_eq_zero]

lemma differentiableAt_gradientCoefficient {z : ℂ} (hz : z ∈ halfPlane) (k : ℝ) :
    DifferentiableAt ℝ (fun w : ℂ => (k : ℂ)*Complex.I/(w.im : ℂ)) z := by
  have hn : (z.im : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr (ne_of_gt hz)
  have hi := ((hasDerivAt_inv hn).differentiableAt.restrictScalars ℝ).comp z
    ((Complex.ofRealCLM.comp Complex.imCLM).differentiableAt)
  simpa only [div_eq_mul_inv,Function.comp_def,ContinuousLinearMap.comp_apply,
    Complex.ofRealCLM_apply,Complex.imCLM_apply] using hi.const_mul ((k : ℂ)*Complex.I)

lemma differentiableAt_regularizedGradient {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {z : ℂ} (hz : z ∈ halfPlane) (k : ℝ) (ξ : ℂ) :
    DifferentiableAt ℝ (regularizedGradient f k ξ) z := by
  have hd := ((hf.1 z hz).differentiableAt (isOpen_halfPlane.mem_nhds hz)).restrictScalars ℝ
  exact ((differentiableAt_gradientCoefficient hz k).mul (hd.sub_const ξ)).mul
    (Complex.conjCLE.differentiableAt.comp z ((differentiableAt_criticalMap hf hz k).sub_const ξ))

lemma hasFDerivAt_regularizedGradient_at_critical {f : ℂ → ℂ}
    (hf : UnivalentOn f halfPlane) {k : ℝ} {ξ z : ℂ} (hz : z ∈ halfPlane)
    (hc : criticalMap f k z = ξ) :
    HasFDerivAt (regularizedGradient f k ξ)
      ((((k : ℂ)*Complex.I/(z.im : ℂ))*(f z-ξ)) •
        (Complex.conjCLE.toContinuousLinearMap.comp (fderiv ℝ (criticalMap f k) z))) z := by
  have hd := ((hf.1 z hz).differentiableAt (isOpen_halfPlane.mem_nhds hz)).restrictScalars ℝ
  have hG := (differentiableAt_criticalMap hf hz k).hasFDerivAt.sub_const ξ
  have hh := ((differentiableAt_gradientCoefficient hz k).hasFDerivAt.fun_mul
    (hd.hasFDerivAt.sub_const ξ)).fun_mul (Complex.conjCLE.hasFDerivAt.comp z hG)
  convert hh using 1 <;> first | rfl | simp only [Function.comp_def, hc, sub_self, map_zero, zero_smul, add_zero]

lemma hasFDerivAt_regularizedGradient_at_pole {f : ℂ → ℂ}
    (hf : UnivalentOn f halfPlane) {k : ℝ} {ξ z : ℂ} (hz : z ∈ halfPlane)
    (hp : f z = ξ) :
    HasFDerivAt (regularizedGradient f k ξ)
      ((((k : ℂ)*Complex.I/(z.im : ℂ))*conj (criticalMap f k z-ξ)) •
        (fderiv ℝ f z)) z := by
  have hd := ((hf.1 z hz).differentiableAt (isOpen_halfPlane.mem_nhds hz)).restrictScalars ℝ
  have hG := (differentiableAt_criticalMap hf hz k).hasFDerivAt.sub_const ξ
  have hh := ((differentiableAt_gradientCoefficient hz k).hasFDerivAt.fun_mul
    (hd.hasFDerivAt.sub_const ξ)).fun_mul (Complex.conjCLE.hasFDerivAt.comp z hG)
  convert hh using 1 <;> first | rfl | simp only [Function.comp_def, hp, sub_self, mul_zero, zero_smul, zero_add, add_zero, smul_smul, Complex.conjCLE_apply, mul_comm]

lemma det_conj_comp (A : ℂ →L[ℝ] ℂ) :
    LinearMap.det (Complex.conjCLE.toContinuousLinearMap.comp A).toLinearMap =
      -LinearMap.det A.toLinearMap := by
  rw [determinant_complex_real,determinant_complex_real]
  simp only [ContinuousLinearMap.coe_coe,ContinuousLinearMap.comp_apply,
    ContinuousLinearEquiv.coe_coe,Complex.conjCLE_apply,Complex.conj_re,Complex.conj_im]
  ring

lemma det_regularizedGradient_at_critical {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {k : ℝ} {ξ z : ℂ} (hz : z ∈ halfPlane) (hc : criticalMap f k z = ξ) :
    LinearMap.det (fderiv ℝ (regularizedGradient f k ξ) z).toLinearMap =
      -‖((k : ℂ)*Complex.I/(z.im : ℂ))*(f z-ξ)‖^2 * ‖deriv f z‖^2 *
        normalizedJacobian f k z := by
  rw [(hasFDerivAt_regularizedGradient_at_critical hf hz hc).fderiv,
    det_complex_smul,det_conj_comp,normalizedJacobian]
  have hd : ‖deriv f z‖ ≠ 0 := norm_ne_zero_iff.mpr
    (univalent_deriv_ne_zero isOpen_halfPlane hf hz)
  field_simp

lemma det_regularizedGradient_at_pole_pos {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {k : ℝ} (hk : k ≠ 0) {ξ z : ℂ} (hz : z ∈ halfPlane) (hp : f z = ξ) :
    0 < LinearMap.det (fderiv ℝ (regularizedGradient f k ξ) z).toLinearMap := by
  have hG : criticalMap f k z ≠ ξ := fun hc => criticalMap_ne_pole hf hk hz hc hp
  rw [(hasFDerivAt_regularizedGradient_at_pole hf hz hp).fderiv,det_complex_smul,
    det_fderiv_complex ((hf.1 z hz).differentiableAt (isOpen_halfPlane.mem_nhds hz))]
  apply mul_pos
  · apply sq_pos_of_pos
    apply norm_pos_iff.mpr
    exact mul_ne_zero (div_ne_zero
      (mul_ne_zero (Complex.ofReal_ne_zero.mpr hk) Complex.I_ne_zero)
      (Complex.ofReal_ne_zero.mpr (ne_of_gt hz)))
      ((map_ne_zero (starRingEnd ℂ)).mpr (sub_ne_zero.mpr hG))
  · exact sq_pos_of_pos (norm_pos_iff.mpr (univalent_deriv_ne_zero isOpen_halfPlane hf hz))

end Brennan

end

end OAI