import OAI.Analysis.IntegralMeans.HalfPlane

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

def logarithmicJet (f : ℂ → ℂ) (z : ℂ) : ℂ :=
  Complex.I * (z.im : ℂ) * deriv (reciprocalDeriv f) z / reciprocalDeriv f z

lemma logarithmicJet_eq {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {z : ℂ} (hz : z ∈ halfPlane) :
    logarithmicJet f z = -Complex.I * (z.im : ℂ) * deriv (deriv f) z / deriv f z := by
  have han : AnalyticAt ℂ f z := hf.1.analyticOnNhd isOpen_halfPlane z hz
  have hd : deriv f z ≠ 0 := univalent_deriv_ne_zero isOpen_halfPlane hf hz
  have hq : deriv (reciprocalDeriv f) z = -deriv (deriv f) z / (deriv f z)^2 :=
    (han.deriv.differentiableAt.hasDerivAt.inv hd).deriv
  rw [logarithmicJet, hq, reciprocalDeriv]
  field_simp

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

def normalizedJacobian (f : ℂ → ℂ) (k : ℝ) (z : ℂ) : ℝ :=
  LinearMap.det (fderiv ℝ (criticalMap f k) z).toLinearMap / ‖deriv f z‖^2

lemma fderiv_criticalMap_apply {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {z : ℂ} (hz : z ∈ halfPlane) (k : ℝ) (v : ℂ) :
    fderiv ℝ (criticalMap f k) z v = deriv f z * v -
      Complex.I / (k : ℂ) * ((v.im : ℂ) * deriv f z +
        (z.im : ℂ) * (deriv (deriv f) z * v)) := by
  have han : AnalyticAt ℂ f z := hf.1.analyticOnNhd isOpen_halfPlane z hz
  have ha := han.differentiableAt.hasDerivAt.hasFDerivAt.restrictScalars ℝ
  have hb := han.deriv.differentiableAt.hasDerivAt.hasFDerivAt.restrictScalars ℝ
  have hc := Complex.ofRealCLM.hasFDerivAt.comp z Complex.imCLM.hasFDerivAt
  have hG := ha.sub ((hc.const_mul (Complex.I / (k : ℂ))).mul hb)
  have hG' : HasFDerivAt (criticalMap f k)
      (ContinuousLinearMap.restrictScalars ℝ (ContinuousLinearMap.toSpanSingleton ℂ (deriv f z)) -
        ((Complex.I / (k : ℂ) * (z.im : ℂ)) •
          ContinuousLinearMap.restrictScalars ℝ (ContinuousLinearMap.toSpanSingleton ℂ (deriv (deriv f) z)) +
        deriv f z • (Complex.I / (k : ℂ)) •
          (Complex.ofRealCLM.comp Complex.imCLM))) z := hG
  rw [hG'.fderiv]
  change v * deriv f z -
    ((Complex.I / (k : ℂ) * (z.im : ℂ)) * (v * deriv (deriv f) z) +
      deriv f z * (Complex.I / (k : ℂ) * (v.im : ℂ))) = _
  ring

lemma criticalMap_columns {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {z : ℂ} (hz : z ∈ halfPlane) (k : ℝ) (hk : k ≠ 0) :
    fderiv ℝ (criticalMap f k) z 1 = deriv f z / (k : ℂ) * ((k : ℂ) + logarithmicJet f z) ∧
    fderiv ℝ (criticalMap f k) z Complex.I =
      Complex.I * (deriv f z / (k : ℂ)) * ((k : ℂ) - 1 + logarithmicJet f z) := by
  have hd : deriv f z ≠ 0 := univalent_deriv_ne_zero isOpen_halfPlane hf hz
  have hk' : (k : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr hk
  constructor <;> rw [fderiv_criticalMap_apply hf hz, logarithmicJet_eq hf hz] <;>
    simp only [Complex.one_im, Complex.I_im, Complex.ofReal_zero, Complex.ofReal_one,
      zero_mul, one_mul, mul_one, zero_add] <;> field_simp <;> ring

lemma critical_columns_det (u q : ℂ) (k : ℝ) :
    (u * ((k : ℂ) + q)).re * (Complex.I * u * ((k : ℂ) - 1 + q)).im -
      (Complex.I * u * ((k : ℂ) - 1 + q)).re * (u * ((k : ℂ) + q)).im =
    ‖u‖^2 * (k * (k-1) + (2*k-1)*q.re + ‖q‖^2) := by
  simp only [Complex.mul_re, Complex.mul_im, Complex.add_re, Complex.add_im,
    Complex.sub_re, Complex.sub_im, Complex.ofReal_re, Complex.ofReal_im,
    Complex.I_re, Complex.I_im, Complex.one_re, Complex.one_im,
    Complex.sq_norm, Complex.normSq_apply]
  ring

lemma normalizedJacobian_formula {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {z : ℂ} (hz : z ∈ halfPlane) (k : ℝ) (hk : k ≠ 0) :
    k^2 * normalizedJacobian f k z =
      k * (k - 1) + (2*k - 1) * (logarithmicJet f z).re + ‖logarithmicJet f z‖^2 := by
  have hd : ‖deriv f z‖ ≠ 0 := norm_ne_zero_iff.mpr
    (univalent_deriv_ne_zero isOpen_halfPlane hf hz)
  obtain ⟨hc₁, hc₂⟩ := criticalMap_columns hf hz k hk
  rw [normalizedJacobian, determinant_complex_real]
  change k ^ 2 * (((fderiv ℝ (criticalMap f k) z 1).re *
    (fderiv ℝ (criticalMap f k) z Complex.I).im -
    (fderiv ℝ (criticalMap f k) z Complex.I).re *
    (fderiv ℝ (criticalMap f k) z 1).im) / ‖deriv f z‖^2) = _
  rw [hc₁, hc₂, critical_columns_det, norm_div, Complex.norm_real,
    Real.norm_eq_abs, div_pow, sq_abs]
  field_simp

lemma hasDerivAt_reciprocalDeriv {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {z : ℂ} (hz : z ∈ halfPlane) :
    HasDerivAt (reciprocalDeriv f) (deriv (reciprocalDeriv f) z) z := by
  have han : AnalyticAt ℂ f z := hf.1.analyticOnNhd isOpen_halfPlane z hz
  exact (han.deriv.differentiableAt.inv
    (univalent_deriv_ne_zero isOpen_halfPlane hf hz)).hasDerivAt

lemma logarithmicJet_reroot {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {z w : ℂ} (hz : z ∈ halfPlane) (hw : w ∈ halfPlane) :
    logarithmicJet (reroot f z) w = logarithmicJet f (affine z w) := by
  have hqz : reciprocalDeriv f z ≠ 0 := inv_ne_zero
    (univalent_deriv_ne_zero isOpen_halfPlane hf hz)
  have hqw : reciprocalDeriv f (affine z w) ≠ 0 := inv_ne_zero
    (univalent_deriv_ne_zero isOpen_halfPlane hf (affine_mem hz hw))
  have heq : reciprocalDeriv (reroot f z) =ᶠ[𝓝 w]
      (fun u => reciprocalDeriv f (affine z u) / reciprocalDeriv f z) := by
    filter_upwards [isOpen_halfPlane.mem_nhds hw] with u hu
    exact reciprocalDeriv_reroot hf hz hu
  have hD := ((((hasDerivAt_reciprocalDeriv hf (affine_mem hz hw)).comp w
    (hasDerivAt_affine z w)).div_const (reciprocalDeriv f z)).congr_of_eventuallyEq heq).deriv
  have him : ((affine z w).im : ℂ) = (z.im : ℂ) * (w.im : ℂ) := by
    simp [affine]
  rw [logarithmicJet, hD, reciprocalDeriv_reroot hf hz hw, logarithmicJet, him]
  field_simp

lemma criticalMap_reroot {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {z w : ℂ} (hz : z ∈ halfPlane) (hw : w ∈ halfPlane) (k : ℝ) :
    criticalMap (reroot f z) k w =
      (criticalMap f k (affine z w) - f z) / ((z.im : ℂ) * deriv f z) := by
  have hy : (z.im : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr (ne_of_gt hz)
  have hd : deriv f z ≠ 0 := univalent_deriv_ne_zero isOpen_halfPlane hf hz
  have him : ((affine z w).im : ℂ) = (z.im : ℂ) * (w.im : ℂ) := by
    simp [affine]
  rw [criticalMap, deriv_reroot hf hz hw]
  simp only [reroot, criticalMap, him]
  field_simp
  ring

lemma normalizedJacobian_reroot {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {z w : ℂ} (hz : z ∈ halfPlane) (hw : w ∈ halfPlane) (k : ℝ) (hk : k ≠ 0) :
    normalizedJacobian (reroot f z) k w = normalizedJacobian f k (affine z w) := by
  apply (mul_left_cancel₀ (pow_ne_zero 2 hk))
  rw [normalizedJacobian_formula (reroot_normalized hf hz).1 hw k hk,
    normalizedJacobian_formula hf (affine_mem hz hw) k hk, logarithmicJet_reroot hf hz hw]

def potential (f : ℂ → ℂ) (k : ℝ) (ξ z : ℂ) : ℝ≥0∞ :=
  (ENNReal.ofReal z.im) ^ k / ENNReal.ofReal ‖f z - ξ‖

def GoodPair (f : ℂ → ℂ) (k : ℝ) (ξ : ℂ) : Prop :=
  (∀ δ : ℝ, 0 < δ → IsCompact {z | z ∈ halfPlane ∧ ENNReal.ofReal δ ≤ potential f k ξ z}) ∧
  (∀ z ∈ halfPlane, criticalMap f k z = ξ → normalizedJacobian f k z ≠ 0)

def CriticalCountStatement : Prop :=
  ∀ f : ℂ → ℂ, UnivalentOn f halfPlane → ∀ k : ℝ, 1 < k → ∀ ξ : ℂ,
    GoodPair f k ξ → ∀ h : ℝ, 0 < h →
      let critical := {z | z ∈ halfPlane ∧ criticalMap f k z = ξ ∧
        ENNReal.ofReal h ≤ potential f k ξ z}
      critical.Finite ∧
      ({z ∈ critical | 0 < normalizedJacobian f k z}).ncard ≤
        ({z ∈ critical | normalizedJacobian f k z < 0}).ncard

lemma differentiableAt_criticalMap {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {z : ℂ} (hz : z ∈ halfPlane) (k : ℝ) :
    DifferentiableAt ℝ (criticalMap f k) z := by
  have han : AnalyticAt ℂ f z := hf.1.analyticOnNhd isOpen_halfPlane z hz
  exact ((han.differentiableAt.restrictScalars ℝ).sub
    (((Complex.ofRealCLM.differentiableAt.comp z Complex.imCLM.differentiableAt).const_mul
      (Complex.I / (k : ℂ))).mul (han.deriv.differentiableAt.restrictScalars ℝ)))

lemma critical_fiber_discrete {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {k : ℝ} {ξ : ℂ} (hreg : ∀ z ∈ halfPlane,
      criticalMap f k z = ξ → normalizedJacobian f k z ≠ 0) :
    IsDiscrete {z | z ∈ halfPlane ∧ criticalMap f k z = ξ} := by
  rw [isDiscrete_iff_nhdsNE]
  intro z hz
  have hd : LinearMap.det (fderiv ℝ (criticalMap f k) z).toLinearMap ≠ 0 :=
    (div_ne_zero_iff.mp (hreg z hz.1 hz.2)).1
  let e : ℂ ≃L[ℝ] ℂ :=
    (LinearMap.equivOfIsUnitDet (isUnit_iff_ne_zero.mpr hd)).toContinuousLinearEquiv
  have he : (e : ℂ → ℂ) = fderiv ℝ (criticalMap f k) z := by
    funext w
    exact LinearMap.equivOfIsUnitDet_apply (isUnit_iff_ne_zero.mpr hd) w
  have ha : ∃ C, AntilipschitzWith C (fderiv ℝ (criticalMap f k) z) := by
    rw [← he]
    exact ⟨_, e.antilipschitz⟩
  rw [Filter.inf_principal_eq_bot]
  filter_upwards [(differentiableAt_criticalMap hf hz.1 k).hasFDerivAt.eventually_ne ha] with w hw
  exact fun h => hw h.2

lemma finite_critical_superlevel {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {k : ℝ} {ξ : ℂ} (hg : GoodPair f k ξ) {h : ℝ} (hh : 0 < h) :
    {z | z ∈ halfPlane ∧ criticalMap f k z = ξ ∧
      ENNReal.ofReal h ≤ potential f k ξ z}.Finite := by
  let P := {z | z ∈ halfPlane ∧ ENNReal.ofReal h ≤ potential f k ξ z}
  have hP : IsCompact P := hg.1 h hh
  have hc : ContinuousOn (criticalMap f k) P := by
    intro z hz
    exact (differentiableAt_criticalMap hf hz.1 k).continuousAt.continuousWithinAt
  have hclosed := hc.preimage_isClosed_of_isClosed hP.isClosed (isClosed_singleton (x := ξ))
  have hcompact : IsCompact (P ∩ (criticalMap f k) ⁻¹' {ξ}) :=
    hP.of_isClosed_subset hclosed inter_subset_left
  have hdiscrete := (critical_fiber_discrete hf hg.2).mono
    (show P ∩ (criticalMap f k) ⁻¹' {ξ} ⊆
      {z | z ∈ halfPlane ∧ criticalMap f k z = ξ} from fun _ hz => ⟨hz.1.1, hz.2⟩)
  convert hcompact.finite hdiscrete using 1
  ext z
  simp only [P, mem_ofPred_eq, mem_inter_iff, mem_preimage, mem_singleton_iff]
  tauto

def logPotential (f : ℂ → ℂ) (k : ℝ) (ξ z : ℂ) : ℝ :=
  k * Real.log z.im - Real.log ‖f z - ξ‖

lemma differentiableAt_log_norm {g : ℂ → ℂ} {z : ℂ}
    (hg : DifferentiableAt ℂ g z) (hn : g z ≠ 0) :
    DifferentiableAt ℝ (fun w => Real.log ‖g w‖) z :=
  ((hg.restrictScalars ℝ).norm ℂ hn).log (norm_ne_zero_iff.mpr hn)

lemma fderiv_log_norm_apply {g : ℂ → ℂ} {d z : ℂ} (hg : HasDerivAt g d z)
    (hn : g z ≠ 0) (v : ℂ) :
    fderiv ℝ (fun w => Real.log ‖g w‖) z v = (d * v / g z).re := by
  have heq : (fun w => Real.log ‖g w‖) =
      (fun w => (1 / 2 : ℝ) * Real.log (‖g w‖ ^ 2)) := by
    funext w
    rw [Real.log_pow]
    ring
  have hh := (((hg.hasFDerivAt.restrictScalars ℝ).norm_sq).log
    (pow_ne_zero 2 (norm_ne_zero_iff.mpr hn))).const_mul (1 / 2 : ℝ)
  rw [heq, hh.fderiv]
  simp only [smul_apply, ContinuousLinearMap.comp_apply,
    ContinuousLinearMap.coe_restrictScalars', ContinuousLinearMap.toSpanSingleton_apply,
    smul_eq_mul, innerSL_apply_apply]
  simp only [Complex.inner, Complex.mul_re, Complex.conj_re, Complex.conj_im,
    Complex.mul_im, Complex.div_re, Complex.normSq_eq_norm_sq]
  ring

lemma differentiableAt_logPotential {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {z ξ : ℂ} (hz : z ∈ halfPlane) (hp : f z ≠ ξ) (k : ℝ) :
    DifferentiableAt ℝ (logPotential f k ξ) z := by
  have hd := (hf.1 z hz).differentiableAt (isOpen_halfPlane.mem_nhds hz)
  exact ((Complex.imCLM.differentiableAt.log (ne_of_gt hz)).const_mul k).sub
    (differentiableAt_log_norm (hd.sub_const ξ) (sub_ne_zero.mpr hp))

lemma fderiv_logPotential_apply {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {z ξ : ℂ} (hz : z ∈ halfPlane) (hp : f z ≠ ξ) (k : ℝ) (v : ℂ) :
    fderiv ℝ (logPotential f k ξ) z v =
      k / z.im * v.im - (deriv f z * v / (f z - ξ)).re := by
  have hd := (hf.1 z hz).differentiableAt (isOpen_halfPlane.mem_nhds hz)
  have ha := (Complex.imCLM.hasFDerivAt.log (ne_of_gt hz)).const_mul k
  simp only [Complex.imCLM_apply] at ha
  have hb := differentiableAt_log_norm (hd.sub_const ξ) (sub_ne_zero.mpr hp)
  change fderiv ℝ (fun w => k * Real.log w.im - Real.log ‖f w - ξ‖) z v = _
  rw [fderiv_fun_sub ha.differentiableAt hb,
    sub_apply, ha.fderiv,
    fderiv_log_norm_apply (hd.hasDerivAt.sub_const ξ) (sub_ne_zero.mpr hp)]
  simp only [smul_apply, smul_eq_mul, Complex.imCLM_apply, div_eq_mul_inv]
  ring

lemma criticalMap_ne_pole {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {k : ℝ} (hk : k ≠ 0) {z ξ : ℂ} (hz : z ∈ halfPlane)
    (hc : criticalMap f k z = ξ) : f z ≠ ξ := by
  intro hp
  have hn := mul_ne_zero (mul_ne_zero (div_ne_zero Complex.I_ne_zero
      (Complex.ofReal_ne_zero.mpr hk)) (Complex.ofReal_ne_zero.mpr (ne_of_gt hz)))
    (univalent_deriv_ne_zero isOpen_halfPlane hf hz)
  apply hn
  simpa [criticalMap, hp] using hc

lemma critical_difference {f : ℂ → ℂ} {k : ℝ} {z ξ : ℂ}
    (hc : criticalMap f k z = ξ) :
    f z - ξ = Complex.I / (k : ℂ) * (z.im : ℂ) * deriv f z := by
  unfold criticalMap at hc
  linear_combination hc

lemma ratio_at_critical {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {k : ℝ} {z ξ : ℂ} (hz : z ∈ halfPlane)
    (hc : criticalMap f k z = ξ) :
    deriv f z / (f z - ξ) = -Complex.I * (k : ℂ) / (z.im : ℂ) := by
  have hd := univalent_deriv_ne_zero isOpen_halfPlane hf hz
  have hy := Complex.ofReal_ne_zero.mpr (ne_of_gt hz)
  rw [critical_difference hc]
  field_simp
  simp [Complex.I_sq]

lemma criticalMap_eq_of_ratio {f : ℂ → ℂ} {k : ℝ} (hk : k ≠ 0)
    {z ξ : ℂ} (hz : z ∈ halfPlane) (hp : f z ≠ ξ)
    (hr : deriv f z / (f z - ξ) = -Complex.I * (k : ℂ) / (z.im : ℂ)) :
    criticalMap f k z = ξ := by
  have hy := Complex.ofReal_ne_zero.mpr (ne_of_gt hz)
  have hk' := Complex.ofReal_ne_zero.mpr hk
  have hdiff := sub_ne_zero.mpr hp
  have hd := (div_eq_iff hdiff).mp hr
  rw [criticalMap, hd]
  field_simp
  simp [Complex.I_sq]

lemma critical_iff_fderiv_logPotential_zero {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {k : ℝ} (hk : k ≠ 0) {z ξ : ℂ} (hz : z ∈ halfPlane) (hp : f z ≠ ξ) :
    criticalMap f k z = ξ ↔ fderiv ℝ (logPotential f k ξ) z = 0 := by
  constructor
  · intro hc
    ext v
    rw [fderiv_logPotential_apply hf hz hp]
    have hr := ratio_at_critical hf hz hc
    rw [show deriv f z * v / (f z - ξ) = (deriv f z / (f z - ξ)) * v by ring, hr]
    simp [Complex.div_re, Complex.div_im, Complex.normSq_ofReal]
    field_simp
    ring
  · intro heq
    have hx := congrArg (fun A : ℂ →L[ℝ] ℝ => A 1) heq
    have hy := congrArg (fun A : ℂ →L[ℝ] ℝ => A Complex.I) heq
    rw [fderiv_logPotential_apply hf hz hp] at hx hy
    simp only [Complex.one_im, mul_zero, mul_one, zero_apply,
      zero_sub, neg_eq_zero] at hx
    have him : (deriv f z / (f z - ξ)).im = -(k / z.im) := by
      rw [show deriv f z * Complex.I / (f z - ξ) =
        (deriv f z / (f z - ξ)) * Complex.I by ring] at hy
      simp only [Complex.I_im, mul_one, Complex.mul_I_re,
        zero_apply] at hy
      linarith
    apply criticalMap_eq_of_ratio hk hz hp
    apply Complex.ext
    · simpa using hx
    · simpa [neg_div] using him

def targetRatio (f : ℂ → ℂ) (ξ z : ℂ) : ℂ := deriv f z / (f z - ξ)

lemma hasDerivAt_targetRatio {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {z ξ : ℂ} (hz : z ∈ halfPlane) (hp : f z ≠ ξ) :
    HasDerivAt (targetRatio f ξ)
      ((deriv (deriv f) z * (f z - ξ) - deriv f z * deriv f z) / (f z - ξ)^2) z := by
  have han : AnalyticAt ℂ f z := hf.1.analyticOnNhd isOpen_halfPlane z hz
  exact han.deriv.differentiableAt.hasDerivAt.div
    (han.differentiableAt.hasDerivAt.sub_const ξ) (sub_ne_zero.mpr hp)

lemma deriv_targetRatio_at_critical {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {k : ℝ} (hk : k ≠ 0) {z ξ : ℂ} (hz : z ∈ halfPlane)
    (hc : criticalMap f k z = ξ) :
    deriv (targetRatio f ξ) z = (k : ℂ) * (k + logarithmicJet f z) / (z.im : ℂ)^2 := by
  have hd := univalent_deriv_ne_zero isOpen_halfPlane hf hz
  have hy := Complex.ofReal_ne_zero.mpr (ne_of_gt hz)
  have hk' := Complex.ofReal_ne_zero.mpr hk
  rw [(hasDerivAt_targetRatio hf hz (criticalMap_ne_pole hf hk hz hc)).deriv,
    critical_difference hc, logarithmicJet_eq hf hz]
  field_simp
  simp only [Complex.I_sq]
  ring_nf

def secondDirectional (u : ℂ → ℝ) (z v w : ℂ) : ℝ :=
  fderiv ℝ (fun t => fderiv ℝ u t v) z w

def realHessian (u : ℂ → ℝ) (z : ℂ) : Matrix (Fin 2) (Fin 2) ℝ :=
  !![secondDirectional u z 1 1, secondDirectional u z 1 Complex.I;
    secondDirectional u z Complex.I 1, secondDirectional u z Complex.I Complex.I]

lemma secondDirectional_logPotential_one {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {z ξ : ℂ} (hz : z ∈ halfPlane) (hp : f z ≠ ξ) (k : ℝ) (v : ℂ) :
    secondDirectional (logPotential f k ξ) z 1 v =
      -(deriv (targetRatio f ξ) z * v).re := 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 1) =ᶠ[𝓝 z]
      (fun w => -(targetRatio f ξ w).re) := by
    filter_upwards [isOpen_halfPlane.mem_nhds hz, hn] with w hw hne
    simp only [fderiv_logPotential_apply hf hw hne, Complex.one_im, mul_zero,
      mul_one, zero_sub, targetRatio]
  have hr := (hasDerivAt_targetRatio hf hz hp).differentiableAt.hasDerivAt
  have hh := (Complex.reCLM.hasFDerivAt.comp z
    (hr.hasFDerivAt.restrictScalars ℝ)).neg
  change HasFDerivAt (fun w => -(targetRatio f ξ w).re) _ z at hh
  rw [secondDirectional, heq.fderiv_eq, hh.fderiv]
  simp only [neg_apply, ContinuousLinearMap.comp_apply,
    ContinuousLinearMap.coe_restrictScalars', ContinuousLinearMap.toSpanSingleton_apply,
    smul_eq_mul, Complex.reCLM_apply, mul_comm v]

lemma secondDirectional_logPotential_I {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {z ξ : ℂ} (hz : z ∈ halfPlane) (hp : f z ≠ ξ) (k : ℝ) (v : ℂ) :
    secondDirectional (logPotential f k ξ) z Complex.I v =
      -k / z.im^2 * v.im + (deriv (targetRatio f ξ) z * v).im := 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 Complex.I) =ᶠ[𝓝 z]
      (fun w => k / w.im + (targetRatio f ξ w).im) := by
    filter_upwards [isOpen_halfPlane.mem_nhds hz, hn] with w hw hne
    rw [fderiv_logPotential_apply hf hw hne,
      show deriv f w * Complex.I / (f w - ξ) =
        (deriv f w / (f w - ξ)) * Complex.I by ring]
    simp only [Complex.I_im, mul_one, Complex.mul_I_re, sub_neg_eq_add, targetRatio]
  have hr := (hasDerivAt_targetRatio hf hz hp).differentiableAt.hasDerivAt
  have ha := (((hasDerivAt_inv (ne_of_gt hz)).hasFDerivAt).comp z
    Complex.imCLM.hasFDerivAt).const_mul k
  have hb := Complex.imCLM.hasFDerivAt.comp z (hr.hasFDerivAt.restrictScalars ℝ)
  have hh := ha.add hb
  change HasFDerivAt (fun w => k * w.im⁻¹ + (targetRatio f ξ w).im) _ z at hh
  simp only [← div_eq_mul_inv] at hh
  rw [secondDirectional, heq.fderiv_eq, hh.fderiv]
  simp only [add_apply, smul_apply, smul_eq_mul, ContinuousLinearMap.comp_apply,
    ContinuousLinearMap.coe_restrictScalars', ContinuousLinearMap.toSpanSingleton_apply,
    Complex.imCLM_apply, mul_comm v]
  ring

lemma realHessian_logPotential {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {z ξ : ℂ} (hz : z ∈ halfPlane) (hp : f z ≠ ξ) (k : ℝ) :
    realHessian (logPotential f k ξ) z =
      !![-(deriv (targetRatio f ξ) z).re, (deriv (targetRatio f ξ) z).im;
        (deriv (targetRatio f ξ) z).im, -k / z.im^2 + (deriv (targetRatio f ξ) z).re] := by
  simp only [realHessian, secondDirectional_logPotential_one hf hz hp,
    secondDirectional_logPotential_I hf hz hp, mul_one, Complex.mul_I_re,
    Complex.mul_I_im, Complex.one_im, Complex.I_im, mul_zero, mul_one, zero_add, neg_neg]

lemma trace_realHessian_logPotential {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {z ξ : ℂ} (hz : z ∈ halfPlane) (hp : f z ≠ ξ) (k : ℝ) :
    Matrix.trace (realHessian (logPotential f k ξ) z) = -k / z.im^2 := by
  rw [realHessian_logPotential hf hz hp]
  simp [Matrix.trace, Matrix.diag, Fin.sum_univ_two]

lemma realHessian_at_critical {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {k : ℝ} (hk : k ≠ 0) {z ξ : ℂ} (hz : z ∈ halfPlane)
    (hc : criticalMap f k z = ξ) :
    realHessian (logPotential f k ξ) z =
      (k / z.im^2) •
        !![-(k + (logarithmicJet f z).re), (logarithmicJet f z).im;
          (logarithmicJet f z).im, k - 1 + (logarithmicJet f z).re] := by
  rw [realHessian_logPotential hf hz (criticalMap_ne_pole hf hk hz hc),
    deriv_targetRatio_at_critical hf hk hz hc]
  have hre : ((k : ℂ) * (k + logarithmicJet f z) / (z.im : ℂ)^2).re =
      k / z.im^2 * (k + (logarithmicJet f z).re) := by
    rw [← Complex.ofReal_pow, Complex.div_ofReal_re]
    simp only [Complex.mul_re, Complex.add_re, Complex.ofReal_re, Complex.ofReal_im,
      zero_mul, sub_zero]
    ring
  have him : ((k : ℂ) * (k + logarithmicJet f z) / (z.im : ℂ)^2).im =
      k / z.im^2 * (logarithmicJet f z).im := by
    rw [← Complex.ofReal_pow, Complex.div_ofReal_im]
    simp only [Complex.mul_im, Complex.add_im, Complex.ofReal_re, Complex.ofReal_im,
      zero_mul, zero_add]
    ring
  rw [hre, him]
  ext i j
  fin_cases i <;> fin_cases j <;> dsimp <;> ring

lemma det_realHessian_at_critical {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {k : ℝ} (hk : k ≠ 0) {z ξ : ℂ} (hz : z ∈ halfPlane)
    (hc : criticalMap f k z = ξ) :
    (realHessian (logPotential f k ξ) z).det =
      -(k^4 / z.im^4) * normalizedJacobian f k z := by
  rw [realHessian_at_critical hf hk hz hc, Matrix.det_fin_two]
  simp only [Matrix.smul_apply, smul_eq_mul, Matrix.of_apply, Matrix.cons_val_zero,
    Matrix.cons_val_one]
  have hJ := normalizedJacobian_formula hf hz k hk
  rw [Complex.sq_norm, Complex.normSq_apply] at hJ
  have hy : z.im ≠ 0 := ne_of_gt hz
  field_simp
  linear_combination hJ

lemma trace_realHessian_negative {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {k : ℝ} (hk : 0 < k) {z ξ : ℂ} (hz : z ∈ halfPlane) (hp : f z ≠ ξ) :
    Matrix.trace (realHessian (logPotential f k ξ) z) < 0 := by
  rw [trace_realHessian_logPotential hf hz hp]
  exact div_neg_of_neg_of_pos (neg_neg_of_pos hk) (sq_pos_of_pos hz)

lemma det_realHessian_ne_zero_at_critical {f : ℂ → ℂ}
    (hf : UnivalentOn f halfPlane) {k : ℝ} (hk : k ≠ 0) {z ξ : ℂ}
    (hz : z ∈ halfPlane) (hc : criticalMap f k z = ξ)
    (hJ : normalizedJacobian f k z ≠ 0) :
    (realHessian (logPotential f k ξ) z).det ≠ 0 := by
  rw [det_realHessian_at_critical hf hk hz hc]
  exact mul_ne_zero (neg_ne_zero.mpr (div_ne_zero (pow_ne_zero 4 hk)
    (pow_ne_zero 4 (ne_of_gt hz)))) hJ

lemma potential_off_pole {f : ℂ → ℂ} {k : ℝ} {ξ z : ℂ}
    (hz : z ∈ halfPlane) (hp : f z ≠ ξ) :
    potential f k ξ z = ENNReal.ofReal (z.im^k / ‖f z - ξ‖) := by
  rw [potential, ENNReal.ofReal_rpow_of_pos hz,
    ENNReal.ofReal_div_of_pos (norm_pos_iff.mpr (sub_ne_zero.mpr hp))]

lemma potential_pos {f : ℂ → ℂ} {k : ℝ} {ξ z : ℂ} (hz : z ∈ halfPlane) :
    0 < potential f k ξ z := by
  rw [potential]
  exact ENNReal.div_pos (ne_of_gt (ENNReal.rpow_pos (ENNReal.ofReal_pos.mpr hz)
    ENNReal.ofReal_ne_top)) ENNReal.ofReal_ne_top

lemma potential_at_pole {f : ℂ → ℂ} {k : ℝ} {ξ z : ℂ}
    (hz : z ∈ halfPlane) (hp : f z = ξ) : potential f k ξ z = ∞ := by
  rw [potential, hp, sub_self, norm_zero, ENNReal.ofReal_zero]
  exact ENNReal.div_zero (ne_of_gt (ENNReal.rpow_pos
    (ENNReal.ofReal_pos.mpr hz) ENNReal.ofReal_ne_top))

lemma potential_critical_height {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {k : ℝ} (hk : 0 < k) {z ξ : ℂ} (hz : z ∈ halfPlane)
    (hc : criticalMap f k z = ξ) :
    potential f k ξ z = ENNReal.ofReal (k * z.im^(k-1) * ‖reciprocalDeriv f z‖) := by
  have hd := univalent_deriv_ne_zero isOpen_halfPlane hf hz
  have hy : z.im ≠ 0 := ne_of_gt hz
  have hn : ‖deriv f z‖ ≠ 0 := norm_ne_zero_iff.mpr hd
  rw [potential_off_pole hz (criticalMap_ne_pole hf (ne_of_gt hk) hz hc),
    critical_difference hc, norm_mul, norm_mul, norm_div, Complex.norm_I,
    Complex.norm_real, Complex.norm_real, Real.norm_eq_abs, Real.norm_eq_abs,
    abs_of_pos hk, abs_of_pos hz, Real.rpow_sub_one hy, reciprocalDeriv, norm_inv]
  congr 1
  field_simp

lemma critical_target_weight {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {β : ℝ} (hβ : 1 < β) {z ξ : ℂ} (hz : z ∈ halfPlane)
    (hc : criticalMap f ((β+3)/4) z = ξ) :
    z.im^(β-1) * ‖reciprocalDeriv f z‖^4 =
      ((potential f ((β+3)/4) ξ z).toReal / ((β+3)/4))^4 := by
  let k : ℝ := (β+3)/4
  have hk : 0 < k := by dsimp [k]; linarith
  have hv : 0 ≤ k * z.im^(k-1) * ‖reciprocalDeriv f z‖ :=
    mul_nonneg (mul_nonneg hk.le (Real.rpow_nonneg hz.le _)) (norm_nonneg _)
  rw [potential_critical_height hf hk hz hc, ENNReal.toReal_ofReal hv]
  have he : β - 1 = (k - 1) * 4 := by dsimp [k]; ring
  rw [he, Real.rpow_mul (le_of_lt hz)]
  change (z.im ^ (k - 1)) ^ (4 : ℝ) * _ = (k * _ * _ / k) ^ (4 : ℕ)
  rw [Real.rpow_ofNat]
  field_simp

end Brennan

end

end OAI