lean/OAI/Analysis/IntegralMeans/CriticalCount.lean

import OAI.Analysis.IntegralMeans.LevelIndex

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 squaredReciprocalPotential (f : ℂ → ℂ) (k : ℝ) (ξ z : ℂ) : ℝ :=
  ‖f z-ξ‖^2 * z.im^(-2*k)

lemma squaredReciprocalPotential_eq_sq {f : ℂ → ℂ} {k : ℝ} {ξ z : ℂ}
    (hz : z ∈ halfPlane) :
    squaredReciprocalPotential f k ξ z = (reciprocalPotential f k ξ z)^2 := by
  rw [squaredReciprocalPotential,reciprocalPotential,div_pow]
  have he : z.im^(-2*k) = ((z.im^k)^2)⁻¹ := by
    rw [show -2*k = -(k*2) by ring, Real.rpow_neg hz.le, Real.rpow_mul hz.le,
      Real.rpow_two]
  rw [he,div_eq_mul_inv]

lemma squaredReciprocalPotential_nonneg {f : ℂ → ℂ} {k : ℝ} {ξ z : ℂ}
    (hz : z ∈ halfPlane) : 0 ≤ squaredReciprocalPotential f k ξ z := by
  rw [squaredReciprocalPotential_eq_sq hz]
  exact sq_nonneg _

lemma contDiffAt_squaredReciprocalPotential {f : ℂ → ℂ}
    (hf : UnivalentOn f halfPlane) {z : ℂ} (hz : z ∈ halfPlane) (k : ℝ) (ξ : ℂ) :
    ContDiffAt ℝ 2 (squaredReciprocalPotential f k ξ) z := by
  have hc : ContDiffAt ℝ 2 f z :=
    (hf.1.analyticOnNhd isOpen_halfPlane z hz).contDiffAt.restrict_scalars ℝ
  exact ((hc.sub contDiffAt_const).norm_sq ℂ).mul
    (Complex.imCLM.contDiff.contDiffAt.rpow_const_of_ne (ne_of_gt hz))

lemma potential_ge_iff_reciprocalPotential_le {f : ℂ → ℂ} {k h : ℝ}
    (hk : 0 ≤ k) (hh : 0 < h) {ξ z : ℂ} (hz : z ∈ halfPlane) :
    ENNReal.ofReal h ≤ potential f k ξ z ↔ reciprocalPotential f k ξ z ≤ h⁻¹ := by
  have hy := Real.rpow_pos_of_pos hz k
  rw [potential,ENNReal.ofReal_rpow_of_nonneg hz.le hk,
    ENNReal.le_div_iff_mul_le
      (Or.inr (ne_of_gt (ENNReal.ofReal_pos.mpr hy))) (Or.inl ENNReal.ofReal_ne_top),
    ← ENNReal.ofReal_mul hh.le,ENNReal.ofReal_le_ofReal_iff hy.le,reciprocalPotential,
    div_le_iff₀ hy,inv_mul_eq_div,le_div_iff₀ hh]
  exact mul_comm h ‖f z-ξ‖ ▸ Iff.rfl

lemma compact_squaredReciprocal_sublevel {f : ℂ → ℂ} {k : ℝ} (hk : 0 ≤ k)
    {ξ : ℂ} (hg : GoodPair f k ξ) {d : ℝ} (hd : 0 < d) :
    IsCompact {z | z ∈ halfPlane ∧ squaredReciprocalPotential f k ξ z ≤ d} := by
  have hs : 0 < Real.sqrt d := Real.sqrt_pos.mpr hd
  have he : {z | z ∈ halfPlane ∧ squaredReciprocalPotential f k ξ z ≤ d} =
      {z | z ∈ halfPlane ∧ ENNReal.ofReal ((Real.sqrt d)⁻¹) ≤ potential f k ξ z} := by
    ext z
    constructor
    · rintro ⟨hz,hzval⟩
      refine ⟨hz,(potential_ge_iff_reciprocalPotential_le hk (inv_pos.mpr hs) hz).mpr ?_⟩
      rw [inv_inv]
      rw [squaredReciprocalPotential_eq_sq hz] at hzval
      nlinarith [Real.sq_sqrt hd.le]
    · rintro ⟨hz,hzval⟩
      have hv := (potential_ge_iff_reciprocalPotential_le hk (inv_pos.mpr hs) hz).mp hzval
      rw [inv_inv] at hv
      refine ⟨hz,?_⟩
      rw [squaredReciprocalPotential_eq_sq hz]
      have hn : 0 ≤ reciprocalPotential f k ξ z := div_nonneg (norm_nonneg _) (Real.rpow_nonneg hz.le _)
      nlinarith [Real.sq_sqrt hd.le]
  rw [he]
  exact hg.1 _ (inv_pos.mpr hs)

lemma regularizedGradient_formula {f : ℂ → ℂ} {k : ℝ} (hk : k ≠ 0)
    {ξ z : ℂ} (hz : z ∈ halfPlane) :
    regularizedGradient f k ξ z =
      ((k : ℂ)*Complex.I/(z.im : ℂ))*((‖f z-ξ‖^2 : ℝ) : ℂ) -
        (f z-ξ)*conj (deriv f z) := by
  have hy : (z.im : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr (ne_of_gt hz)
  have hkc : (k : ℂ) ≠ 0 := Complex.ofReal_ne_zero.mpr hk
  have he : conj (criticalMap f k z-ξ) = conj (f z-ξ) +
      Complex.I/(k : ℂ)*(z.im : ℂ)*conj (deriv f z) := by
    simp only [criticalMap, div_eq_mul_inv, map_sub, map_mul, map_inv₀, Complex.conj_I, Complex.conj_ofReal]
    ring
  rw [regularizedGradient,he,mul_add, mul_assoc _ (f z-ξ),Complex.mul_conj',
    ← Complex.ofReal_pow]
  field_simp
  ring_nf
  simp only [Complex.I_sq]
  ring

lemma fderiv_squaredReciprocalPotential_apply {f : ℂ → ℂ}
    (hf : UnivalentOn f halfPlane) {k : ℝ} (hk : k ≠ 0)
    {ξ z : ℂ} (hz : z ∈ halfPlane) (v : ℂ) :
    fderiv ℝ (squaredReciprocalPotential f k ξ) z v =
      -2*z.im^(-2*k)*(regularizedGradient f k ξ z * conj v).re := by
  have hd := (((hf.1 z hz).differentiableAt (isOpen_halfPlane.mem_nhds hz)).hasDerivAt.sub_const ξ).hasFDerivAt.restrictScalars ℝ
  have hy := Complex.imCLM.hasFDerivAt.rpow_const (p := -2*k) (Or.inl (ne_of_gt hz))
  have hu := hd.norm_sq.fun_mul hy
  simp only [Complex.imCLM_apply] at hu
  change (fderiv ℝ (fun w => ‖f w - ξ‖ ^ 2 * w.im ^ (-2*k)) z) v = _
  rw [hu.fderiv]
  simp only [smul_apply,add_apply,ContinuousLinearMap.comp_apply,
    ContinuousLinearMap.coe_restrictScalars',ContinuousLinearMap.toSpanSingleton_apply,
    smul_eq_mul,innerSL_apply_apply,Complex.imCLM_apply]
  rw [regularizedGradient_formula hk hz,Real.rpow_sub hz,Real.rpow_one]
  simp only [Complex.inner,Complex.mul_re,Complex.mul_im,Complex.conj_re,Complex.conj_im,
    Complex.sub_re,Complex.sub_im,Complex.div_re,Complex.div_im,Complex.ofReal_re,
    Complex.ofReal_im,Complex.I_re,Complex.I_im,Complex.normSq_ofReal]
  field_simp [ne_of_gt (show 0 < z.im from hz)]
  ring

lemma fderiv_squaredReciprocalPotential_eq_zero_iff {f : ℂ → ℂ}
    (hf : UnivalentOn f halfPlane) {k : ℝ} (hk : k ≠ 0)
    {ξ z : ℂ} (hz : z ∈ halfPlane) :
    fderiv ℝ (squaredReciprocalPotential f k ξ) z = 0 ↔
      regularizedGradient f k ξ z = 0 := by
  constructor
  · intro hzero
    have hh := fderiv_squaredReciprocalPotential_apply hf hk (ξ := ξ) hz
      (regularizedGradient f k ξ z)
    rw [hzero, zero_apply, Complex.mul_conj', ← Complex.ofReal_pow, Complex.ofReal_re] at hh
    have hp := Real.rpow_pos_of_pos hz (-2*k)
    have hn := norm_nonneg (regularizedGradient f k ξ z)
    apply norm_eq_zero.mp
    have hsq : ‖regularizedGradient f k ξ z‖^2 = 0 :=
      (mul_eq_zero.mp hh.symm).resolve_left (mul_ne_zero (by norm_num) (ne_of_gt hp))
    nlinarith
  · intro hzero
    ext v
    rw [fderiv_squaredReciprocalPotential_apply hf hk hz v, hzero]
    simp

lemma det_regularizedGradient_ne_zero {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {k : ℝ} (hk : k ≠ 0) {ξ : ℂ} (hg : GoodPair f k ξ)
    {z : ℂ} (hz : z ∈ halfPlane) (hzero : regularizedGradient f k ξ z = 0) :
    LinearMap.det (fderiv ℝ (regularizedGradient f k ξ) z).toLinearMap ≠ 0 := by
  rcases (regularizedGradient_eq_zero_iff hk hz).mp hzero with hp | hc
  · exact ne_of_gt (det_regularizedGradient_at_pole_pos hf hk hz hp)
  · rw [det_regularizedGradient_at_critical hf hz hc]
    apply mul_ne_zero
    · apply mul_ne_zero
      · exact neg_ne_zero.mpr (pow_ne_zero 2 (norm_ne_zero_iff.mpr
          (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)))
            (sub_ne_zero.mpr (criticalMap_ne_pole hf hk hz hc)))))
      · exact pow_ne_zero 2 (norm_ne_zero_iff.mpr
          (univalent_deriv_ne_zero isOpen_halfPlane hf hz))
    · exact hg.2 z hz hc

lemma compact_convex_halfPlane_envelope {P : Set ℂ} (hP : IsCompact P)
    (hPH : P ⊆ halfPlane) :
    ∃ K : Set ℂ, IsCompact K ∧ Convex ℝ K ∧ P ⊆ K ∧ K ⊆ halfPlane := by
  obtain ⟨η,hη,hheight⟩ := hP.exists_forall_le' Complex.continuous_im.continuousOn hPH
  obtain ⟨R,hR⟩ := hP.isBounded.subset_closedBall (0 : ℂ)
  refine ⟨Metric.closedBall 0 R ∩ {z : ℂ | η ≤ z.im},
    (isCompact_closedBall 0 R).inter_right (isClosed_le continuous_const Complex.continuous_im),
    (convex_closedBall (0 : ℂ) R).inter (convex_halfSpace_im_ge η),?_,?_⟩
  · exact fun z hz => ⟨hR hz,hheight z hz⟩
  · exact fun z hz => hη.trans_le hz.2

lemma continuous_extension_near_compact {K U : Set ℂ} (hK : IsCompact K)
    (hU : IsOpen U) (hKU : K ⊆ U) {x : ℂ → ℂ}
    (hx : ∀ z ∈ U, ContinuousAt x z) :
    ∃ X : C(ℂ,ℂ), ∀ z ∈ K, (X : ℂ → ℂ) =ᶠ[𝓝 z] x := by
  obtain ⟨χ,hχc,_hχK,hχU,hχ1,_hχrange⟩ := exists_smooth_cutoff hK hU hKU
  let X := fun z => (χ z : ℂ)*x z
  have hX : Continuous X := by
    rw [continuous_iff_continuousAt]
    intro z
    by_cases hz : z ∈ tsupport χ
    · exact (Complex.continuous_ofReal.continuousAt.comp hχc.continuous.continuousAt).mul
        (hx z (hχU hz))
    · have he : X =ᶠ[𝓝 z] fun _ => 0 := by
        filter_upwards [isClosed_tsupport χ |>.isOpen_compl.mem_nhds hz] with w hw
        have hzero : χ w = 0 := notMem_support.mp (fun h => hw (subset_tsupport χ h))
        simp only [X,hzero,Complex.ofReal_zero,zero_mul]
      exact continuousAt_const.congr he.symm
  refine ⟨⟨X,hX⟩,?_⟩
  intro z hz
  filter_upwards [hχ1 z hz] with w hw
  simp only [ContinuousMap.coe_mk,X,hw,Complex.ofReal_one,one_mul]

lemma squaredReciprocalPotential_lt_windingInterior {f : ℂ → ℂ}
    (hf : UnivalentOn f halfPlane) {k c : ℝ} (hk : 0 < k) (hc : 0 < c) (ξ : ℂ)
    (γ : C(unitInterval,ℂ)) (hloop : γ 1 = γ 0) (hγ : ∀ t, γ t ∈ halfPlane)
    (hlevel : ∀ t, squaredReciprocalPotential f k ξ (γ t) = c)
    {z : ℂ} (hz : z ∈ windingInterior γ) :
    z ∈ halfPlane ∧ squaredReciprocalPotential f k ξ z < c := by
  have hzH := closure_windingInterior_subset_halfPlane γ hloop hγ (subset_closure hz)
  have hb : 0 < Real.sqrt c := Real.sqrt_pos.mpr hc
  have hl (t) : reciprocalPotential f k ξ (γ t) = Real.sqrt c := by
    have hsq := hlevel t
    rw [squaredReciprocalPotential_eq_sq (hγ t)] at hsq
    have hn : 0 ≤ reciprocalPotential f k ξ (γ t) :=
      div_nonneg (norm_nonneg _) (Real.rpow_nonneg (hγ t).le _)
    nlinarith [Real.sq_sqrt hc.le]
  have hh := reciprocalPotential_lt_on_windingInterior hf hk hb ξ γ hloop hγ hl hz
  have hn : 0 ≤ reciprocalPotential f k ξ z :=
    div_nonneg (norm_nonneg _) (Real.rpow_nonneg hzH.le _)
  refine ⟨hzH,?_⟩
  rw [squaredReciprocalPotential_eq_sq hzH]
  nlinarith [Real.sq_sqrt hc.le]

lemma regular_potential_level_index_sum {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {k : ℝ} (hk : 0 < k) {ξ : ℂ} (hg : GoodPair f k ξ) {c : ℝ} (hc : 0 < c)
    (hreg : ∀ z ∈ halfPlane, squaredReciprocalPotential f k ξ z = c →
      regularizedGradient f k ξ z ≠ 0) :
    ∃ (s : Finset ℂ) (N : ℕ),
      (∀ z ∈ s, z ∈ halfPlane ∧ regularizedGradient f k ξ z = 0) ∧
      (∀ z ∈ halfPlane, squaredReciprocalPotential f k ξ z < c →
        (z ∈ s ↔ regularizedGradient f k ξ z = 0)) ∧
      (∑ z ∈ s, if squaredReciprocalPotential f k ξ z < c then
        planeIndex (fderiv ℝ (regularizedGradient f k ξ) z) else 0) = (N : ℤ) ∧
      ((∃ z ∈ halfPlane, f z = ξ) → 1 ≤ N) := by
  classical
  let u := squaredReciprocalPotential f k ξ
  let x := regularizedGradient f k ξ
  let d := c+1
  have hcd : c < d := by dsimp [d]; linarith
  have hd : 0 < d := hc.trans hcd
  have hP := compact_squaredReciprocal_sublevel hk.le hg hd
  obtain ⟨K,hK,hKcv,hPK,hKH⟩ := compact_convex_halfPlane_envelope hP (fun _ h => h.1)
  obtain ⟨F,hFc,hFs,hFeq,hFout,hFle,hFlt⟩ := extend_compact_sublevel isOpen_halfPlane
    (fun z hz => contDiffAt_squaredReciprocalPotential hf hz k ξ) hP
  have hlevel (z) (hz : F z = c) : z ∈ halfPlane ∧ u z = c := by
    have hh := (hFle z c hcd).mp hz.le
    exact ⟨hh.1, ((hFeq z hh.1 (hh.2.trans hcd.le)).self_of_nhds).symm.trans hz⟩
  have hFreg (z) (hz : F z = c) : fderiv ℝ F z ≠ 0 := by
    obtain ⟨hzH,huz⟩ := hlevel z hz
    rw [(hFeq z hzH (huz.le.trans hcd.le)).fderiv_eq]
    exact fun hh => hreg z hzH huz ((fderiv_squaredReciprocalPotential_eq_zero_iff
      hf (ne_of_gt hk) hzH).mp hh)
  have hL : IsCompact {z | F z = c} := hP.of_isClosed_subset
    (isClosed_eq hFc.continuous continuous_const)
    (fun z hz => ⟨(hlevel z hz).1, (hlevel z hz).2.le.trans hcd.le⟩)
  obtain ⟨C,hC,hdis,hcurves⟩ := compact_regular_level_oriented_curves hFc hFs hFreg hL
  let ι := {S : Set ℂ // S ∈ C}
  choose γ hγrange hγc hγp hγi hγd hγm hγr hγdown using
    (fun S : ι => hcurves S.1 S.2)
  have hγlevel (i : ι) (t : ℝ) : F (γ i t) = c := by
    have hh : γ i t ∈ ⋃ S ∈ C, S := mem_iUnion₂.mpr
      ⟨i.1,i.2,hγrange i ▸ mem_range_self t⟩
    rwa [hC] at hh
  have hγH (i : ι) (t : ℝ) : γ i t ∈ halfPlane := (hlevel _ (hγlevel i t)).1
  have hγu (i : ι) (t : ℝ) : u (γ i t) = c := (hlevel _ (hγlevel i t)).2
  have hcover (z) : F z = c ↔ ∃ i : ι, z ∈ range (γ i) := by
    constructor
    · intro hz
      have hm : z ∈ ⋃ S ∈ C, S := hC.symm ▸ hz
      obtain ⟨S,hS,hzS⟩ := mem_iUnion₂.mp hm
      exact ⟨⟨S,hS⟩, (hγrange ⟨S,hS⟩).symm ▸ hzS⟩
    · rintro ⟨i,t,rfl⟩
      exact hγlevel i t
  have hγdis (i j : ι) (hij : i ≠ j) : Disjoint (range (γ i)) (range (γ j)) := by
    rw [hγrange,hγrange]
    exact hdis i.1 i.2 j.1 j.2 (Subtype.val_injective.ne hij)
  have hbelow (i : ι) (w : ℂ) (hw : w ∉ range (γ i))
      (hind : loopIndex (periodicLoop (hγc i).continuous 0) w ≠ 0) : F w < c := by
    have hw' : w ∈ windingInterior (periodicLoop (hγc i).continuous 0) :=
      ⟨by rwa [periodicLoop_range _ (hγp i) 0],hind⟩
    have hh := squaredReciprocalPotential_lt_windingInterior hf hk hc ξ
      (periodicLoop (hγc i).continuous 0) (periodicLoop_closed _ (hγp i) 0)
      (fun t => hγH i ((t:ℝ)+0)) (fun t => hγu i ((t:ℝ)+0)) hw'
    exact (hFlt w c hcd).mpr hh
  have hFzero : F 0 = d := hFout 0 (by simp [halfPlane])
  have habove : ∃ z, c < F z := ⟨0,hFzero ▸ hcd⟩
  obtain ⟨X,hXeq⟩ := continuous_extension_near_compact hK isOpen_halfPlane hKH
    (fun z hz => (differentiableAt_regularizedGradient hf hz k ξ).continuousAt)
  have hfinite : {z | z ∈ K ∧ x z = 0}.Finite := finite_regular_zeros_on_compact hK
    (fun z hz => (differentiableAt_regularizedGradient hf (hKH hz) k ξ).continuousAt.continuousWithinAt)
    (fun z hz hzero => ⟨differentiableAt_regularizedGradient hf (hKH hz) k ξ,
      det_regularizedGradient_ne_zero hf (ne_of_gt hk) hg (hKH hz) hzero⟩)
  let s := hfinite.toFinset
  have hs (z) : z ∈ s ↔ z ∈ K ∧ x z = 0 := hfinite.mem_toFinset
  have hsK (z) (hz : z ∈ s) : z ∈ K := ((hs z).mp hz).1
  have hXzero (z) (hz : z ∈ K) : X z = 0 ↔ z ∈ s := by
    rw [(hXeq z hz).self_of_nhds,hs]
    exact ⟨fun h => ⟨hz,h⟩,fun h => h.2⟩
  have hD (z) (hz : z ∈ s) :
      HasFDerivAt X (fderiv ℝ x z) z ∧ LinearMap.det (fderiv ℝ x z).toLinearMap ≠ 0 := by
    refine ⟨(differentiableAt_regularizedGradient hf (hKH (hsK z hz)) k ξ).hasFDerivAt.congr_of_eventuallyEq
      (hXeq z (hsK z hz)),?_⟩
    exact det_regularizedGradient_ne_zero hf (ne_of_gt hk) hg (hKH (hsK z hz)) ((hs z).mp hz).2
  have hγK (i : ι) (t : ℝ) : γ i t ∈ K := hPK ⟨hγH i t,(hγu i t).le.trans hcd.le⟩
  have hX (i : ι) (t : ℝ) : X (γ i t) ≠ 0 := by
    rw [(hXeq _ (hγK i t)).self_of_nhds]
    exact hreg _ (hγH i t) (hγu i t)
  have horth (i : ι) (t : ℝ) : (X (γ i t)*conj (deriv (γ i) t)).re = 0 := by
    have he : HasDerivAt (fun q => F (γ i q))
        (fderiv ℝ F (γ i t) (deriv (γ i) t)) t :=
      ((hFc.differentiable (by norm_num)) _).hasFDerivAt.comp_hasDerivAt t
        (((hγc i).differentiable (by norm_num)) t).hasDerivAt
    have he0 : fderiv ℝ F (γ i t) (deriv (γ i) t) = 0 :=
      (he.congr_of_eventuallyEq (Filter.Eventually.of_forall (fun q => (hγlevel i q).symm))).unique (hasDerivAt_const t c)
    rw [(hFeq _ (hγH i t) ((hγu i t).le.trans hcd.le)).fderiv_eq,
      fderiv_squaredReciprocalPotential_apply hf (ne_of_gt hk) (hγH i t)] at he0
    rw [(hXeq _ (hγK i t)).self_of_nhds]
    exact (mul_eq_zero.mp he0).resolve_left (mul_ne_zero (by norm_num)
      (ne_of_gt (Real.rpow_pos_of_pos (hγH i t) (-2*k))))
  have hsum := regular_level_index_sum hFc.continuous γ hγc hγp hγi hγd hγm hγr hγdown
    hγlevel (fun z hz => ⟨hFc.contDiffAt.of_le (by norm_num),hFreg z hz⟩)
    hcover hγdis hbelow habove hKcv hγK s X (fderiv ℝ x) hsK hXzero hD hX horth
  refine ⟨s,Fintype.card ι,?_,?_,?_,?_⟩
  · intro z hz
    exact ⟨hKH (hsK z hz),((hs z).mp hz).2⟩
  · intro z hzH hzu
    rw [hs]
    exact ⟨fun h => h.2,fun hx => ⟨hPK ⟨hzH,hzu.le.trans hcd.le⟩,hx⟩⟩
  · convert hsum using 1
    apply Finset.sum_congr rfl
    intro z hz
    simp only [show (F z < c) ↔ u z < c from (hFlt z c hcd).trans
      (and_iff_right (hKH (hsK z hz)))]
    rfl
  · rintro ⟨z,hzH,hpole⟩
    have huz : u z = 0 := by simp [u,squaredReciprocalPotential,hpole]
    have hFz : F z = 0 := (hFeq z hzH (huz.le.trans hd.le)).self_of_nhds.trans huz
    obtain ⟨w,hw⟩ := intermediate_value_univ z 0 hFc.continuous
      (show c ∈ Icc (F z) (F 0) by rw [hFz,hFzero]; exact ⟨hc.le,hcd.le⟩)
    obtain ⟨i,_hi⟩ := (hcover w).mp hw
    exact Nat.succ_le_iff.mpr (Fintype.card_pos_iff.mpr ⟨i⟩)

lemma planeIndex_regularizedGradient_at_critical {f : ℂ → ℂ}
    (hf : UnivalentOn f halfPlane) {k : ℝ} (hk : k ≠ 0)
    {ξ z : ℂ} (hz : z ∈ halfPlane) (hcrit : criticalMap f k z = ξ) :
    planeIndex (fderiv ℝ (regularizedGradient f k ξ) z) =
      if normalizedJacobian f k z < 0 then 1 else -1 := by
  have hp : 0 < ‖((k : ℂ)*Complex.I/(z.im : ℂ))*(f z-ξ)‖^2 * ‖deriv f z‖^2 := by
    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)))
        (sub_ne_zero.mpr (criticalMap_ne_pole hf hk hz hcrit))
    · exact sq_pos_of_pos (norm_pos_iff.mpr (univalent_deriv_ne_zero isOpen_halfPlane hf hz))
  rw [planeIndex,det_regularizedGradient_at_critical hf hz hcrit]
  congr 1
  apply propext
  rw [neg_mul,neg_mul,neg_pos]
  constructor
  · intro h
    by_contra hn
    exact (not_lt_of_ge (mul_nonneg hp.le (le_of_not_gt hn))) h
  · exact mul_neg_of_pos_of_neg hp

lemma critical_count_strict_sublevel {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {k : ℝ} (hk : 0 < k) {ξ : ℂ} (hg : GoodPair f k ξ) {c : ℝ} (hc : 0 < c)
    (hreg : ∀ z ∈ halfPlane, squaredReciprocalPotential f k ξ z = c →
      regularizedGradient f k ξ z ≠ 0) :
    let critical := {z | z ∈ halfPlane ∧ criticalMap f k z = ξ ∧
      squaredReciprocalPotential f k ξ z < c}
    critical.Finite ∧ ({z ∈ critical | 0 < normalizedJacobian f k z}).ncard ≤
      ({z ∈ critical | normalizedJacobian f k z < 0}).ncard := by
  classical
  dsimp only
  obtain ⟨s,N,hs,hsall,hsum,hpole⟩ := regular_potential_level_index_sum hf hk hg hc hreg
  let u := squaredReciprocalPotential f k ξ
  let p := s.filter (fun z => u z < c ∧ f z = ξ)
  let m := s.filter (fun z => u z < c ∧ criticalMap f k z = ξ ∧ normalizedJacobian f k z < 0)
  let a := s.filter (fun z => u z < c ∧ criticalMap f k z = ξ ∧ 0 < normalizedJacobian f k z)
  have hcritmem (z) (hz : z ∈ halfPlane) (hG : criticalMap f k z = ξ) (hu : u z < c) : z ∈ s :=
    (hsall z hz hu).mpr ((regularizedGradient_eq_zero_iff (ne_of_gt hk) hz).mpr (Or.inr hG))
  have hfinite : {z | z ∈ halfPlane ∧ criticalMap f k z = ξ ∧ u z < c}.Finite :=
    s.finite_toSet.subset (fun z hz => hcritmem z hz.1 hz.2.1 hz.2.2)
  have hmset : {z | (z ∈ halfPlane ∧ criticalMap f k z = ξ ∧ u z < c) ∧
      normalizedJacobian f k z < 0} = (m : Set ℂ) := by
    ext z
    simp only [m,Finset.mem_coe,Finset.mem_filter,mem_ofPred_eq]
    constructor
    · rintro ⟨⟨hz,hG,hu⟩,hJ⟩
      exact ⟨hcritmem z hz hG hu,hu,hG,hJ⟩
    · rintro ⟨hz,hu,hG,hJ⟩
      exact ⟨⟨(hs z hz).1,hG,hu⟩,hJ⟩
  have haset : {z | (z ∈ halfPlane ∧ criticalMap f k z = ξ ∧ u z < c) ∧
      0 < normalizedJacobian f k z} = (a : Set ℂ) := by
    ext z
    simp only [a,Finset.mem_coe,Finset.mem_filter,mem_ofPred_eq]
    constructor
    · rintro ⟨⟨hz,hG,hu⟩,hJ⟩
      exact ⟨hcritmem z hz hG hu,hu,hG,hJ⟩
    · rintro ⟨hz,hu,hG,hJ⟩
      exact ⟨⟨(hs z hz).1,hG,hu⟩,hJ⟩
  have hpcard : p.card ≤ 1 := by
    apply Finset.card_le_one.mpr
    intro z hz w hw
    obtain ⟨hz,huz,hpz⟩ := Finset.mem_filter.mp hz
    obtain ⟨hw,huw,hpw⟩ := Finset.mem_filter.mp hw
    exact hf.2 (hs z hz).1 (hs w hw).1 (hpz.trans hpw.symm)
  have hpN : p.card ≤ N := by
    by_cases hpe : p = ∅
    · simp [hpe]
    · obtain ⟨z,hz⟩ := Finset.nonempty_iff_ne_empty.mpr hpe
      obtain ⟨hz,huz,hpz⟩ := Finset.mem_filter.mp hz
      exact hpcard.trans (hpole ⟨z,(hs z hz).1,hpz⟩)
  have hterm (z) (hz : z ∈ s) :
      (if u z < c then planeIndex (fderiv ℝ (regularizedGradient f k ξ) z) else 0) =
        (if u z < c ∧ f z = ξ then (1 : ℤ) else 0) +
        (if u z < c ∧ criticalMap f k z = ξ ∧ normalizedJacobian f k z < 0 then 1 else 0) -
        (if u z < c ∧ criticalMap f k z = ξ ∧ 0 < normalizedJacobian f k z then 1 else 0) := by
    by_cases hu : u z < c
    · simp only [hu,true_and,ite_true]
      rcases (regularizedGradient_eq_zero_iff (ne_of_gt hk) (hs z hz).1).mp (hs z hz).2 with hpz | hG
      · have hGn : criticalMap f k z ≠ ξ := fun h => criticalMap_ne_pole hf (ne_of_gt hk) (hs z hz).1 h hpz
        simp [hpz,hGn,planeIndex,det_regularizedGradient_at_pole_pos hf (ne_of_gt hk) (hs z hz).1 hpz]
      · have hpn := criticalMap_ne_pole hf (ne_of_gt hk) (hs z hz).1 hG
        rw [planeIndex_regularizedGradient_at_critical hf (ne_of_gt hk) (hs z hz).1 hG]
        rcases lt_or_gt_of_ne (hg.2 z (hs z hz).1 hG) with hJ | hJ
        · simp [hpn,hG,hJ,not_lt_of_ge hJ.le]
        · simp [hpn,hG,hJ,not_lt_of_ge hJ.le]
    · simp [hu]
  have heuler : (p.card : ℤ) + m.card - a.card = N := by
    rw [← hsum]
    calc
      (p.card : ℤ) + m.card - a.card =
          ∑ z ∈ s, ((if u z < c ∧ f z = ξ then (1 : ℤ) else 0) +
            (if u z < c ∧ criticalMap f k z = ξ ∧ normalizedJacobian f k z < 0 then 1 else 0) -
            (if u z < c ∧ criticalMap f k z = ξ ∧ 0 < normalizedJacobian f k z then 1 else 0)) := by
        simp only [Finset.sum_sub_distrib,Finset.sum_add_distrib,Finset.sum_boole,p,m,a]
      _ = _ := Finset.sum_congr rfl (fun z hz => (hterm z hz).symm)
  refine ⟨hfinite,?_⟩
  change ({z | (z ∈ halfPlane ∧ criticalMap f k z = ξ ∧ u z < c) ∧
      0 < normalizedJacobian f k z}).ncard ≤
    ({z | (z ∈ halfPlane ∧ criticalMap f k z = ξ ∧ u z < c) ∧
      normalizedJacobian f k z < 0}).ncard
  rw [haset,hmset,Set.ncard_coe_finset,Set.ncard_coe_finset]
  omega

lemma finite_critical_squared_sublevel {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {k : ℝ} (hk : 0 ≤ k) {ξ : ℂ} (hg : GoodPair f k ξ) {d : ℝ} (hd : 0 < d) :
    {z | z ∈ halfPlane ∧ criticalMap f k z = ξ ∧
      squaredReciprocalPotential f k ξ z ≤ d}.Finite := by
  have hs : 0 < Real.sqrt d := Real.sqrt_pos.mpr hd
  apply (finite_critical_superlevel hf hg (h := (Real.sqrt d)⁻¹) (inv_pos.mpr hs)).subset
  intro z hz
  refine ⟨hz.1,hz.2.1,(potential_ge_iff_reciprocalPotential_le hk (inv_pos.mpr hs) hz.1).mpr ?_⟩
  rw [inv_inv]
  have hh := hz.2.2
  rw [squaredReciprocalPotential_eq_sq hz.1] at hh
  nlinarith [Real.sq_sqrt hd.le]

lemma potential_ge_iff_squaredReciprocal_le {f : ℂ → ℂ} {k h : ℝ}
    (hk : 0 ≤ k) (hh : 0 < h) {ξ z : ℂ} (hz : z ∈ halfPlane) :
    ENNReal.ofReal h ≤ potential f k ξ z ↔
      squaredReciprocalPotential f k ξ z ≤ (h⁻¹)^2 := by
  rw [potential_ge_iff_reciprocalPotential_le hk hh hz,squaredReciprocalPotential_eq_sq hz]
  exact (sq_le_sq₀ (div_nonneg (norm_nonneg _) (Real.rpow_nonneg hz.le _))
    (inv_nonneg.mpr hh.le)).symm

lemma finset_gap_above (s : Finset ℝ) (r d : ℝ) (hrd : r < d) :
    ∃ c, r < c ∧ c < d ∧ ∀ a ∈ s, r < a → c < a := by
  classical
  induction s using Finset.induction_on generalizing d with
  | empty =>
    obtain ⟨c,hrc,hcd⟩ := exists_between hrd
    exact ⟨c,hrc,hcd,by simp⟩
  | @insert a s ha ih =>
    by_cases hra : r < a
    · obtain ⟨c,hrc,hcd,hcs⟩ := ih (min d a) (lt_min hrd hra)
      refine ⟨c,hrc,hcd.trans_le (min_le_left _ _),?_⟩
      intro b hb hrb
      rcases Finset.mem_insert.mp hb with rfl | hb
      · exact hcd.trans_le (min_le_right _ _)
      · exact hcs b hb hrb
    · obtain ⟨c,hrc,hcd,hcs⟩ := ih d hrd
      refine ⟨c,hrc,hcd,?_⟩
      intro b hb hrb
      rcases Finset.mem_insert.mp hb with rfl | hb
      · exact (hra hrb).elim
      · exact hcs b hb hrb

theorem critical_count {f : ℂ → ℂ} (hf : UnivalentOn f halfPlane)
    {k : ℝ} (hk : 0 < k) {ξ : ℂ} (hg : GoodPair f k ξ) {h : ℝ} (hh : 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 := by
  classical
  let u := squaredReciprocalPotential f k ξ
  let r := (h⁻¹)^2
  have hr : 0 < r := sq_pos_of_pos (inv_pos.mpr hh)
  have hd : 0 < r+1 := by linarith
  have hfinite := finite_critical_squared_sublevel hf hk.le hg hd
  let s := hfinite.toFinset.image u
  obtain ⟨c,hrc,hcd,hcs⟩ := finset_gap_above s r (r+1) (by linarith)
  have hcmem (z) (hz : z ∈ halfPlane) (hG : criticalMap f k z = ξ)
      (hu : u z ≤ r+1) : u z ∈ s :=
    Finset.mem_image.mpr ⟨z,hfinite.mem_toFinset.mpr ⟨hz,hG,hu⟩,rfl⟩
  have hcut (z) (hz : z ∈ halfPlane) (hG : criticalMap f k z = ξ) : u z < c ↔ u z ≤ r := by
    constructor
    · intro huc
      by_contra hn
      have hru : r < u z := lt_of_not_ge hn
      exact (hcs (u z) (hcmem z hz hG (huc.trans hcd).le) hru).not_gt huc
    · exact fun h => h.trans_lt hrc
  have hreg (z) (hz : z ∈ halfPlane) (huc : u z = c) : regularizedGradient f k ξ z ≠ 0 := by
    intro hzero
    rcases (regularizedGradient_eq_zero_iff (ne_of_gt hk) hz).mp hzero with hp | hG
    · have huz : u z = 0 := by simp [u,squaredReciprocalPotential,hp]
      linarith
    · have hmem := hcmem z hz hG (huc.le.trans hcd.le)
      have hcc := hcs (u z) hmem (hrc.trans_eq huc.symm)
      linarith
  have hc := critical_count_strict_sublevel hf hk hg (hr.trans hrc) hreg
  have he : {z | z ∈ halfPlane ∧ criticalMap f k z = ξ ∧ ENNReal.ofReal h ≤ potential f k ξ z} =
      {z | z ∈ halfPlane ∧ criticalMap f k z = ξ ∧ u z < c} := by
    ext z
    constructor
    · rintro ⟨hz,hG,hV⟩
      exact ⟨hz,hG,(hcut z hz hG).mpr ((potential_ge_iff_squaredReciprocal_le hk.le hh hz).mp hV)⟩
    · rintro ⟨hz,hG,hu⟩
      exact ⟨hz,hG,(potential_ge_iff_squaredReciprocal_le hk.le hh hz).mpr ((hcut z hz hG).mp hu)⟩
  dsimp only
  rw [he]
  exact hc

theorem criticalCountStatement_proved : CriticalCountStatement := by
  intro f hf k hk ξ hg h hh
  exact critical_count hf (lt_trans zero_lt_one hk) hg hh

end Brennan

end

end OAI