import OAI.Analysis.IntegralMeans.UnivalentArea

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 polar_symm_eq_circleMap (r θ : ℝ) :
    Complex.polarCoord.symm (r,θ) = circleMap 0 r θ := by
  rw [Complex.polarCoord_symm_apply, circleMap, zero_add]
  congr 1
  rw [Complex.exp_mul_I]
  simp

lemma circleAverage_eq_integral_neg_pi (f : ℂ → ℂ) (c : ℂ) (r : ℝ) :
    Real.circleAverage f c r =
      (2*Real.pi)⁻¹ • ∫ θ in -Real.pi..Real.pi, f (circleMap c r θ) := by
  rw [Real.circleAverage_eq_integral_add (-Real.pi)]
  rw [intervalIntegral.integral_comp_add_right (fun θ => f (circleMap c r θ))]
  congr 2 <;> ring

lemma integral_ball_polar {f : ℂ → ℂ} {R : ℝ} (hR : 0 < R)
    (hf : ContinuousOn f (Metric.closedBall 0 R)) :
    ∫ z in Metric.ball (0 : ℂ) R, f z =
      ∫ r in (0 : ℝ)..R, (2*Real.pi*r) • Real.circleAverage f 0 r := by
  let g : ℝ × ℝ → ℂ := fun p => p.1 • f (Complex.polarCoord.symm p)
  have hg : IntegrableOn g (Ioo (0 : ℝ) R ×ˢ Ioo (-Real.pi) Real.pi) := by
    refine (show IntegrableOn g (Icc (0 : ℝ) R ×ˢ Icc (-Real.pi) Real.pi) from ?_).mono_set ?_
    · apply ContinuousOn.integrableOn_compact (isCompact_Icc.prod isCompact_Icc)
      have hpolar : Continuous (fun p : ℝ × ℝ => Complex.polarCoord.symm p) := by
        simp only [Complex.polarCoord_symm_apply]
        fun_prop
      apply continuousOn_fst.smul (hf.comp hpolar.continuousOn ?_)
      intro p hp
      simp only [Metric.mem_closedBall, dist_zero_right, Complex.norm_polarCoord_symm]
      exact (abs_of_nonneg hp.1.1).trans_le hp.1.2
    · exact prod_mono Ioo_subset_Icc_self Ioo_subset_Icc_self
  calc
    _ = ∫ p in polarCoord.target,
        p.1 • (Metric.ball (0 : ℂ) R).indicator f (Complex.polarCoord.symm p) := by
      rw [Complex.integral_comp_polarCoord_symm,
        integral_indicator Metric.isOpen_ball.measurableSet]
    _ = ∫ p in Ioo (0 : ℝ) R ×ˢ Ioo (-Real.pi) Real.pi, g p := by
      rw [polarCoord_target]
      have heq : (fun p : ℝ × ℝ => p.1 •
          (Metric.ball (0 : ℂ) R).indicator f (Complex.polarCoord.symm p)) =ᶠ[
          ae (volume.restrict (Ioi (0 : ℝ) ×ˢ Ioo (-Real.pi) Real.pi))]
        (Iio R ×ˢ (univ : Set ℝ)).indicator g := by
        filter_upwards [ae_restrict_mem (measurableSet_Ioi.prod measurableSet_Ioo)] with p hp
        have hp0 : 0 < p.1 := hp.1
        have hn : ‖Complex.polarCoord.symm p‖ = p.1 := by
          rw [Complex.norm_polarCoord_symm,abs_of_pos hp0]
        by_cases hr : p.1 < R
        · rw [indicator_of_mem (by simpa [Metric.mem_ball,dist_zero_right,Complex.norm_polarCoord_symm,abs_of_pos hp0] using hr),
            indicator_of_mem (show p ∈ Iio R ×ˢ (univ : Set ℝ) from ⟨hr,mem_univ _⟩)]
        · rw [indicator_of_notMem (by simpa [Metric.mem_ball,dist_zero_right,Complex.norm_polarCoord_symm,abs_of_pos hp0] using hr),
            indicator_of_notMem (show p ∉ Iio R ×ˢ (univ : Set ℝ) from fun h => hr h.1),smul_zero]
      rw [integral_congr_ae heq,
        integral_indicator (measurableSet_Iio.prod MeasurableSet.univ)]
      rw [Measure.restrict_restrict (measurableSet_Iio.prod MeasurableSet.univ)]
      congr 2
      ext p
      simp only [mem_inter_iff, mem_prod, mem_Ioi, mem_Iio, mem_Ioo, mem_univ, and_true]
      tauto
    _ = ∫ r in Ioo (0 : ℝ) R, ∫ θ in Ioo (-Real.pi) Real.pi, g (r,θ) := by
      exact setIntegral_prod _ (by simpa only [← Measure.volume_eq_prod] using hg)
    _ = ∫ r in (0 : ℝ)..R, (2*Real.pi*r) • Real.circleAverage f 0 r := by
      rw [intervalIntegral.integral_of_le hR.le, integral_Ioc_eq_integral_Ioo]
      apply setIntegral_congr_fun measurableSet_Ioo
      intro r hr
      dsimp only
      rw [circleAverage_eq_integral_neg_pi,
        intervalIntegral.integral_of_le (neg_le_self Real.pi_pos.le),
        integral_Ioc_eq_integral_Ioo, ← smul_assoc]
      have he : (2*Real.pi*r) * (2*Real.pi)⁻¹ = r := by
        field_simp
      rw [smul_eq_mul, he, ← integral_smul]
      apply setIntegral_congr_fun measurableSet_Ioo
      intro θ hθ
      simp only [g, polar_symm_eq_circleMap]

lemma ball_closedBall_ae_eq (r : ℝ) :
    Metric.ball (0 : ℂ) r =ᵐ[volume] Metric.closedBall 0 r := by
  apply ae_eq_set.mpr
  constructor
  · rw [sdiff_eq_empty.mpr Metric.ball_subset_closedBall,measure_empty]
  · rw [Metric.closedBall_sdiff_ball]
    exact Measure.addHaar_sphere volume 0 r

lemma integral_ball_holomorphic {f : ℂ → ℂ} {R r : ℝ}
    (hf : DifferentiableOn ℂ f (Metric.ball (0 : ℂ) R))
    (hr : 0 < r) (hrR : r < R) :
    ∫ z in Metric.ball (0 : ℂ) r, f z = volume.real (Metric.ball (0 : ℂ) r) • f 0 := by
  have hfc : ContinuousOn f (Metric.closedBall 0 r) :=
    hf.continuousOn.mono (Metric.closedBall_subset_ball hrR)
  rw [integral_ball_polar hr hfc]
  have hm (t : ℝ) (ht : t ∈ Ioo 0 r) : Real.circleAverage f 0 t = f 0 := by
    apply DiffContOnCl.circleAverage
    rw [abs_of_pos ht.1]
    apply DifferentiableOn.diffContOnCl
    rw [closure_ball 0 ht.1.ne']
    exact hf.mono (Metric.closedBall_subset_ball (ht.2.trans hrR))
  have hc := integral_ball_polar (f := fun _ : ℂ => f 0) hr continuousOn_const
  rw [setIntegral_const] at hc
  rw [hc]
  apply intervalIntegral.integral_congr
  intro t ht
  rw [uIcc_of_le hr.le] at ht
  by_cases ht0 : t = 0
  · simp [ht0]
  have htpos : 0 < t := lt_of_le_of_ne ht.1 (Ne.symm ht0)
  have ht' : t ∈ Ioo 0 r ∨ t = r := by
    exact (lt_or_eq_of_le ht.2).elim (fun h => Or.inl ⟨htpos,h⟩) Or.inr
  have hmf : Real.circleAverage f 0 t = f 0 := by
    rcases ht' with ht' | rfl
    · exact hm t ht'
    · apply DiffContOnCl.circleAverage
      rw [abs_of_pos hr]
      apply DifferentiableOn.diffContOnCl
      rw [closure_ball 0 hr.ne']
      exact hf.mono (Metric.closedBall_subset_ball hrR)
  simp only [hmf,Real.circleAverage_const]

lemma integral_closedBall_holomorphic {f : ℂ → ℂ} {R r : ℝ}
    (hf : DifferentiableOn ℂ f (Metric.ball (0 : ℂ) R))
    (hr : 0 < r) (hrR : r < R) :
    ∫ z in Metric.closedBall (0 : ℂ) r, f z =
      volume.real (Metric.closedBall (0 : ℂ) r) • f 0 := by
  rw [← setIntegral_congr_set (ball_closedBall_ae_eq r),
    integral_ball_holomorphic hf hr hrR]
  congr 1
  exact congrArg ENNReal.toReal (measure_congr (ball_closedBall_ae_eq r))

lemma holomorphic_sq_submean {f : ℂ → ℂ} {R r : ℝ}
    (hf : DifferentiableOn ℂ f (Metric.ball (0 : ℂ) R))
    (hr : 0 < r) (hrR : r < R) :
    volume.real (Metric.closedBall (0 : ℂ) r) * ‖f 0‖^2 ≤
      ∫ z in Metric.closedBall (0 : ℂ) r, ‖f z‖^2 := by
  let K : Set ℂ := Metric.closedBall 0 r
  have hfc : ContinuousOn f K := hf.continuousOn.mono (Metric.closedBall_subset_ball hrR)
  have hfi : IntegrableOn f K := hfc.integrableOn_compact (isCompact_closedBall 0 r)
  have hf2i : IntegrableOn (fun z => ‖f z‖^2) K :=
    (hfc.norm.pow 2).integrableOn_compact (isCompact_closedBall 0 r)
  have hconst : IntegrableOn (fun _ : ℂ => ‖f 0‖^2) K :=
    integrableOn_const (isCompact_closedBall 0 r).measure_ne_top
  have hnonneg : 0 ≤ ∫ z in K, ‖f z-f 0‖^2 := integral_nonneg (fun _ => sq_nonneg _)
  have he : (fun z => ‖f z-f 0‖^2) =
      (fun z => ‖f z‖^2-2*inner ℝ (f 0) (f z)+‖f 0‖^2) := by
    funext z
    rw [norm_sub_sq_real,real_inner_comm]
  have hsub : IntegrableOn (fun z => ‖f z‖^2-2*inner ℝ (f 0) (f z)) K :=
    hf2i.sub ((hfi.const_inner (f 0)).const_mul 2)
  have hinner : IntegrableOn (fun z => 2*inner ℝ (f 0) (f z)) K :=
    (hfi.const_inner (f 0)).const_mul 2
  rw [he,integral_add hsub hconst,
    integral_sub hf2i hinner,
    integral_const_mul,integral_inner hfi,setIntegral_const,
    integral_closedBall_holomorphic hf hr hrR,real_inner_smul_right,
    real_inner_self_eq_norm_sq,smul_eq_mul] at hnonneg
  dsimp only [K] at hnonneg ⊢
  linarith

lemma meromorphic_univalent_coefficient {h H : ℂ → ℂ}
    (hh : DifferentiableOn ℂ h (Metric.ball 0 1))
    (hH : DifferentiableOn ℂ H (Metric.ball 0 1 \ {0}))
    (hdef : ∀ z ∈ Metric.ball (0 : ℂ) 1, z ≠ 0 → H z = z⁻¹+h z)
    (hHd : ∀ z ∈ Metric.ball (0 : ℂ) 1 \ {0}, deriv H z ≠ 0)
    (hHi : InjOn H (Metric.ball 0 1 \ {0})) : ‖deriv h 0‖ ≤ 1 := by
  have hb (r : ℝ) (hr : 0 < r) (hr1 : r < 1) : ‖deriv h 0‖^2 ≤ (r^2)⁻¹^2 := by
    have hM : 0 < volume.real (Metric.closedBall (0 : ℂ) r) := by
      rw [measureReal_def,Complex.volume_closedBall,ENNReal.toReal_mul,ENNReal.toReal_pow,
        ENNReal.toReal_ofReal hr.le,ENNReal.coe_toReal]
      exact mul_pos (sq_pos_of_pos hr) Real.pi_pos
    have hle := (holomorphic_sq_submean (hh.deriv Metric.isOpen_ball) hr hr1).trans
      (meromorphic_univalent_area hh hH hdef hHd hHi hr hr1)
    nlinarith
  have ht : Tendsto (fun r : ℝ => (r^2)⁻¹^2) (𝓝[<] (1 : ℝ)) (𝓝 1) := by
    have hc : ContinuousAt (fun r : ℝ => (r^2)⁻¹^2) 1 :=
      ((continuousAt_id.pow 2).inv₀ (by norm_num)).pow 2
    simpa using hc.tendsto.mono_left nhdsWithin_le_nhds
  have hsq : ‖deriv h 0‖^2 ≤ 1 := by
    apply ge_of_tendsto ht
    filter_upwards [self_mem_nhdsWithin,
      (show ∀ᶠ r : ℝ in 𝓝[<] (1 : ℝ), 0 < r from
        nhdsWithin_le_nhds (Ioi_mem_nhds (by norm_num : (0 : ℝ)<1)))] with r hr1 hr
    exact hb r hr hr1
  nlinarith [norm_nonneg (deriv h 0)]

lemma nonconstant_germ_of_injOn {f : ℂ → ℂ} {U : Set ℂ}
    (hU : IsOpen U) (hf : Set.InjOn f U) {a : ℂ} (ha : a ∈ U) :
    ¬ ∀ᶠ z in 𝓝 a, f z = f a := by
  intro hc
  have heq : ∀ᶠ z in 𝓝 a, z = a := by
    filter_upwards [hc, hU.mem_nhds ha] with z hz hzU
    exact hf hzU ha hz
  have heq' : ∀ᶠ z in 𝓝[≠] a, z = a := heq.filter_mono nhdsWithin_le_nhds
  have hne' : ∀ᶠ z in 𝓝[≠] a, z ≠ a := self_mem_nhdsWithin
  obtain ⟨z, hz, hne⟩ := (heq'.and hne').exists
  exact hne hz

lemma univalent_inverse_continuousAt {f : ℂ → ℂ} {U : Set ℂ}
    (hU : IsOpen U) (hf : UnivalentOn f U) {a : ℂ} (ha : a ∈ U) :
    ContinuousAt (Function.invFunOn f U) (f a) := by
  have haan : AnalyticAt ℂ f a := (hf.1.analyticOnNhd hU) a ha
  have hopen : 𝓝 (f a) ≤ Filter.map f (𝓝 a) :=
    haan.eventually_constant_or_nhds_le_map_nhds.resolve_left
      (nonconstant_germ_of_injOn hU hf.2 ha)
  have hl : ∀ᶠ z in 𝓝 a, Function.invFunOn f U (f z) = z := by
    filter_upwards [hU.mem_nhds ha] with z hz
    exact hf.2.leftInvOn_invFunOn hz
  have ht : Tendsto (Function.invFunOn f U ∘ f) (𝓝 a) (𝓝 a) :=
    tendsto_id.congr' (Filter.EventuallyEq.symm hl)
  rw [ContinuousAt, hf.2.leftInvOn_invFunOn ha]
  exact (tendsto_map'_iff.mpr ht).mono_left hopen

lemma univalent_deriv_ne_zero {f : ℂ → ℂ} {U : Set ℂ}
    (hU : IsOpen U) (hf : UnivalentOn f U) {a : ℂ} (ha : a ∈ U) :
    deriv f a ≠ 0 := by
  have han : AnalyticAt ℂ f a := hf.1.analyticOnNhd hU a ha
  have hd_nonconst : ¬ ∀ᶠ z in 𝓝 a, deriv f z = 0 := by
    intro hc
    obtain ⟨r, hr, hball⟩ := Metric.mem_nhds_iff.mp (hc.and (hU.mem_nhds ha))
    have hfball : DifferentiableOn ℂ f (Metric.ball a r) :=
      hf.1.mono (fun z hz => (hball hz).2)
    have hcball : ∀ z ∈ Metric.ball a r, f z = f a := by
      intro z hz
      exact Metric.isOpen_ball.is_const_of_deriv_eq_zero (convex_ball a r).isPreconnected
        hfball (fun w hw => (hball hw).1) hz (Metric.mem_ball_self hr)
    apply nonconstant_germ_of_injOn hU hf.2 ha
    filter_upwards [Metric.ball_mem_nhds a hr] with z hz
    exact hcball z hz
  have hd : ∀ᶠ z in 𝓝[≠] a, deriv f z ≠ 0 :=
    han.deriv.eventually_eq_zero_or_eventually_ne_zero.resolve_left hd_nonconst
  let g := Function.invFunOn f U
  have hgc : ContinuousAt g (f a) := univalent_inverse_continuousAt hU hf ha
  have hga : g (f a) = a := hf.2.leftInvOn_invFunOn ha
  have hopen : 𝓝 (f a) ≤ Filter.map f (𝓝 a) :=
    han.eventually_constant_or_nhds_le_map_nhds.resolve_left
      (nonconstant_germ_of_injOn hU hf.2 ha)
  have hright : ∀ᶠ w in 𝓝 (f a), g w ∈ U ∧ f (g w) = w := by
    apply (hopen (Filter.mem_map.mpr ?_))
    filter_upwards [hU.mem_nhds ha] with z hz
    exact ⟨Function.invFunOn_apply_mem hz, Function.invFunOn_apply_eq hz⟩
  have hgne : ∀ᶠ w in 𝓝[≠] (f a), g w ≠ a := by
    filter_upwards [hright.filter_mono nhdsWithin_le_nhds, self_mem_nhdsWithin]
      with w hw hwne
    intro heq
    exact hwne (hw.2.symm.trans (congrArg f heq))
  have hgt : Tendsto g (𝓝[≠] (f a)) (𝓝[≠] a) := by
    apply tendsto_nhdsWithin_iff.mpr
    refine ⟨?_, hgne⟩
    simpa only [hga] using (hgc.tendsto.mono_left nhdsWithin_le_nhds :
      Tendsto g (𝓝[≠] (f a)) (𝓝 (g (f a))))
  have hgd : ∀ᶠ w in 𝓝[≠] (f a), DifferentiableAt ℂ g w := by
    filter_upwards [hgt.eventually hd, hright.filter_mono nhdsWithin_le_nhds]
      with w hwder hw
    have hwan : AnalyticAt ℂ f (g w) := hf.1.analyticOnNhd hU (g w) hw.1
    have hws : HasStrictDerivAt f (deriv f (g w)) (g w) :=
      (hwan.contDiffAt (n := 1)).hasStrictDerivAt (by norm_num)
    have hl : ∀ᶠ z in 𝓝 (g w), g (f z) = z := by
      filter_upwards [hU.mem_nhds hw.1] with z hz
      exact hf.2.leftInvOn_invFunOn hz
    simpa [hw.2] using (hws.to_local_left_inverse hwder hl).hasDerivAt.differentiableAt
  have hgan := Complex.analyticAt_of_differentiable_on_punctured_nhds_of_continuousAt
    hgd hgc
  have hcomp := hgan.differentiableAt.hasDerivAt.comp a han.differentiableAt.hasDerivAt
  have hid : (fun z => g (f z)) =ᶠ[𝓝 a] id := by
    filter_upwards [hU.mem_nhds ha] with z hz
    exact hf.2.leftInvOn_invFunOn hz
  have hprod : deriv g (f a) * deriv f a = 1 := by
    simpa using (hcomp.congr_of_eventuallyEq hid.symm).unique (hasDerivAt_id a)
  intro hzero
  simp [hzero] at hprod

lemma differentiableAt_of_continuous_root {q F : ℂ → ℂ} {z : ℂ}
    (hq : ContinuousAt q z) (hF : DifferentiableAt ℂ F z)
    (hroot : (fun w => q w^2) =ᶠ[𝓝 z] F) (hq0 : q z ≠ 0) :
    DifferentiableAt ℂ q z := by
  have hp : HasStrictDerivAt (fun w : ℂ => w^2) (2*q z) (q z) := by
    have hp := (hasStrictDerivAt_id (q z)).pow 2
    change HasStrictDerivAt (fun w : ℂ => w^2) _ (q z) at hp
    simpa only [id_eq, Nat.reduceSub, pow_one, Nat.cast_ofNat, mul_one] using hp
  have hn : 2*q z ≠ 0 := mul_ne_zero (by norm_num) hq0
  let p := hp.localInverse _ _ _ hn
  have hpD : DifferentiableAt ℂ p (F z) := by
    rw [← hroot.self_of_nhds]
    exact (hp.to_localInverse hn).hasDerivAt.differentiableAt
  have he : q =ᶠ[𝓝 z] fun w => p (F w) := by
    filter_upwards [hq.tendsto.eventually (hp.eventually_left_inverse hn),hroot] with w hw hwF
    exact (hwF ▸ hw).symm
  exact (hpD.comp z hF).congr_of_eventuallyEq he

lemma exists_holomorphic_sqrt_disk {F : ℂ → ℂ}
    (hF : DifferentiableOn ℂ F disk) (hF0 : ∀ z ∈ disk, F z ≠ 0)
    (hFone : F 0 = 1) :
    ∃ q : ℂ → ℂ, DifferentiableOn ℂ q disk ∧ q 0 = 1 ∧
      (∀ z ∈ disk, q z^2 = F z) ∧ ∀ z ∈ disk, q z ≠ 0 := by
  have hdz : (0 : ℂ) ∈ disk := by simp [disk]
  have hsim : IsSimplyConnected disk := by
    have : ContractibleSpace disk := (convex_ball (0 : ℂ) (1 : ℝ)).contractibleSpace ⟨0,hdz⟩
    change SimplyConnectedSpace disk
    exact inferInstance
  obtain ⟨q,hqc,hq⟩ := Complex.exists_continuousOn_pow_eq hsim Metric.isOpen_ball hF.continuousOn
    (by rintro ⟨z,hz,he⟩;exact hF0 z hz he) (n := 2) (by norm_num)
  have hqn (z) (hz : z ∈ disk) : q z ≠ 0 := by
    intro he
    have := hq z
    rw [he,zero_pow (by norm_num)] at this
    exact hF0 z hz this.symm
  have hqd : DifferentiableOn ℂ q disk := by
    intro z hz
    apply DifferentiableAt.differentiableWithinAt
    apply differentiableAt_of_continuous_root
      (hqc.continuousAt (Metric.isOpen_ball.mem_nhds hz))
      ((hF z hz).differentiableAt (Metric.isOpen_ball.mem_nhds hz))
      (Filter.Eventually.of_forall hq) (hqn z hz)
  let Q : ℂ → ℂ := fun z => q z / q 0
  refine ⟨Q,hqd.div_const _,by simp [Q,hqn 0 hdz],?_,?_⟩
  · intro z hz
    simp only [Q,div_pow,hq,hFone,div_one]
  · intro z hz
    exact div_ne_zero (hqn z hz) (hqn 0 hdz)

lemma dslope_factor (f : ℂ → ℂ) (z : ℂ) :
    z * dslope f 0 z = f z-f 0 := by
  simpa only [sub_zero,smul_eq_mul] using sub_smul_dslope f 0 z

lemma sq_mem_disk {z : ℂ} (hz : z ∈ disk) : z^2 ∈ disk := by
  have hn : ‖z‖ < 1 := by simpa [disk] using hz
  simpa [disk] using pow_lt_one₀ (norm_nonneg z) hn (by norm_num : 2 ≠ 0)

lemma exists_odd_transform {f : ℂ → ℂ} (hf : Schlicht f) :
    ∃ q g h H : ℂ → ℂ,
      DifferentiableOn ℂ q disk ∧ q 0 = 1 ∧
      (∀ z ∈ disk, q z ≠ 0) ∧
      (∀ z ∈ disk, q z^2 = dslope f 0 z) ∧
      (∀ z, g z = z*q (z^2)) ∧
      UnivalentOn g disk ∧ g 0 = 0 ∧
      DifferentiableOn ℂ h disk ∧ deriv h 0 = -deriv q 0 ∧
      (∀ z ∈ disk, z ≠ 0 → H z = z⁻¹+h z) ∧
      UnivalentOn H (disk \ {0}) ∧
      deriv (deriv f) 0 = 4*deriv q 0 := by
  have hdz : (0 : ℂ) ∈ disk := by simp [disk]
  let F := dslope f 0
  have hFd : DifferentiableOn ℂ F disk :=
    (Complex.differentiableOn_dslope (Metric.isOpen_ball.mem_nhds hdz)).mpr hf.1.1
  have hFn (z) (hz : z ∈ disk) : F z ≠ 0 := by
    by_cases hz0 : z = 0
    · simpa [F,hz0] using (show deriv f 0 ≠ 0 by rw [hf.2.2];norm_num)
    · intro he
      have hfact := dslope_factor f z
      change z*F z = f z-f 0 at hfact
      rw [he,mul_zero] at hfact
      exact hz0 (hf.1.2 hz hdz (sub_eq_zero.mp hfact.symm))
  obtain ⟨q,hqd,hq0,hqs,hqn⟩ := exists_holomorphic_sqrt_disk hFd hFn (by simpa [F] using hf.2.2)
  let Q := dslope q 0
  have hQd : DifferentiableOn ℂ Q disk :=
    (Complex.differentiableOn_dslope (Metric.isOpen_ball.mem_nhds hdz)).mpr hqd
  let g : ℂ → ℂ := fun z => z*q (z^2)
  let h : ℂ → ℂ := fun z => -z*Q (z^2)/q (z^2)
  let H : ℂ → ℂ := fun z => (g z)⁻¹
  have hgd : DifferentiableOn ℂ g disk := by
    exact differentiableOn_id.mul (hqd.comp (differentiableOn_id.pow 2) (fun z hz => sq_mem_disk hz))
  have hgs (z) (hz : z ∈ disk) : g z^2 = f (z^2) := by
    dsimp only [g]
    rw [mul_pow,hqs _ (sq_mem_disk hz)]
    simpa [F,hf.2.1] using dslope_factor f (z^2)
  have hgn (z) (hz : z ∈ disk) (hz0 : z ≠ 0) : g z ≠ 0 :=
    mul_ne_zero hz0 (hqn _ (sq_mem_disk hz))
  have hgi : InjOn g disk := by
    intro z hz w hw he
    have hsq : z^2 = w^2 := hf.1.2 (sq_mem_disk hz) (sq_mem_disk hw)
      ((hgs z hz).symm.trans ((congrArg (fun t => t^2) he).trans (hgs w hw)))
    rcases sq_eq_sq_iff_eq_or_eq_neg.mp hsq with heq | heq
    · exact heq
    · have hgneg : g z = -g w := by simp [g,heq]
      have hw0 : w = 0 := by
        by_contra hn
        exact hgn w hw hn (by linear_combination (he.symm+hgneg)/2)
      simpa [hw0] using heq
  have hhd : DifferentiableOn ℂ h disk := by
    exact (differentiableOn_id.neg.mul
      (hQd.comp (differentiableOn_id.pow 2) (fun z hz => sq_mem_disk hz))).div
      (hqd.comp (differentiableOn_id.pow 2) (fun z hz => sq_mem_disk hz))
      (fun z hz => hqn _ (sq_mem_disk hz))
  have hderh : deriv h 0 = -deriv q 0 := by
    have hqd0 := ((hqd 0 hdz).differentiableAt (Metric.isOpen_ball.mem_nhds hdz)).hasDerivAt
    have hQd0 := ((hQd 0 hdz).differentiableAt (Metric.isOpen_ball.mem_nhds hdz)).hasDerivAt
    have hp : HasDerivAt (fun z : ℂ => z^2) 0 0 := by
      have hp := (hasDerivAt_id (0 : ℂ)).pow 2
      change HasDerivAt (fun z : ℂ => z^2) _ 0 at hp
      simpa only [id_eq,Nat.reduceSub,pow_one,Nat.cast_ofNat,mul_one,mul_zero] using hp
    have hQcomp : HasDerivAt (fun z : ℂ => Q (z^2)) 0 0 := by
      have hQd0' : HasDerivAt Q (deriv Q 0) ((0 : ℂ)^2) := by simpa using hQd0
      convert hQd0'.comp (h := fun z : ℂ => z^2) 0 hp using 1 <;> first | rfl | simp
    have hqcomp : HasDerivAt (fun z : ℂ => q (z^2)) 0 0 := by
      have hqd0' : HasDerivAt q (deriv q 0) ((0 : ℂ)^2) := by simpa using hqd0
      convert hqd0'.comp (h := fun z : ℂ => z^2) 0 hp using 1 <;> first | rfl | simp
    have hD := ((hasDerivAt_id (0 : ℂ)).neg.mul hQcomp).div hqcomp
      (by simpa using hqn 0 hdz)
    change HasDerivAt h _ 0 at hD
    simpa [Q,hq0] using hD.deriv
  have hdef (z) (hz : z ∈ disk) (hz0 : z ≠ 0) : H z = z⁻¹+h z := by
    have hfact := dslope_factor q (z^2)
    rw [hq0] at hfact
    change z^2 * Q (z^2) = q (z^2)-1 at hfact
    dsimp only [H,g,h]
    field_simp [hz0,hqn _ (sq_mem_disk hz)]
    linear_combination hfact
  have hHu : UnivalentOn H (disk \ {0}) := by
    refine ⟨(hgd.mono sdiff_subset).inv (fun z hz => hgn z hz.1 hz.2),?_⟩
    intro z hz w hw he
    exact hgi hz.1 hw.1 (inv_inj.mp he)
  have hFq : deriv F 0 = 2*deriv q 0 := by
    have hD := (((hqd 0 hdz).differentiableAt (Metric.isOpen_ball.mem_nhds hdz)).hasDerivAt).pow 2
    have he : (fun z => q z^2) =ᶠ[𝓝 (0 : ℂ)] F := by
      filter_upwards [Metric.isOpen_ball.mem_nhds hdz] with z hz
      exact hqs z hz
    have := (hD.congr_of_eventuallyEq he.symm).deriv
    simpa [hq0] using this
  have hff : deriv (deriv f) 0 = 2*deriv F 0 := by
    have hidentity : f = fun z => z*F z := by
      funext z
      simpa [hf.2.1,F] using (dslope_factor f z).symm
    have he : deriv f =ᶠ[𝓝 (0 : ℂ)] fun z => F z+z*deriv F z := by
      filter_upwards [Metric.isOpen_ball.mem_nhds hdz] with z hz
      have hD := (hasDerivAt_id z).mul
        (((hFd z hz).differentiableAt (Metric.isOpen_ball.mem_nhds hz)).hasDerivAt)
      rw [hidentity]
      change HasDerivAt (fun w => w*F w) _ z at hD
      simpa using hD.deriv
    have hD := (((hFd 0 hdz).differentiableAt (Metric.isOpen_ball.mem_nhds hdz)).hasDerivAt).add
      ((hasDerivAt_id (0 : ℂ)).mul
        (((hFd.deriv Metric.isOpen_ball 0 hdz).differentiableAt (Metric.isOpen_ball.mem_nhds hdz)).hasDerivAt))
    have := (hD.congr_of_eventuallyEq he).deriv
    simpa [two_mul] using this
  refine ⟨q,g,h,H,hqd,hq0,hqn,hqs,fun _ => rfl,⟨hgd,hgi⟩,by simp [g],hhd,hderh,hdef,hHu,?_⟩
  rw [hff,hFq]
  ring

lemma schlicht_second_deriv_bound {f : ℂ → ℂ} (hf : Schlicht f) :
    ‖deriv (deriv f) 0‖ ≤ 4 := by
  obtain ⟨q,g,h,H,hqd,hq0,hqn,hqs,hgd,hgu,hg0,hhd,hderh,hdef,hHu,hff⟩ :=
    exists_odd_transform hf
  have hbound : ‖deriv h 0‖ ≤ 1 :=
    meromorphic_univalent_coefficient hhd hHu.1 hdef
      (fun z hz => univalent_deriv_ne_zero
        (Metric.isOpen_ball.sdiff isClosed_singleton) hHu hz) hHu.2
  rw [hderh,norm_neg] at hbound
  rw [hff,norm_mul]
  norm_num
  linarith

def diskAutomorphism (a z : ℂ) : ℂ := (z+a)/(1+starRingEnd ℂ a*z)

lemma diskAutomorphism_den_ne_zero {a z : ℂ} (ha : a ∈ disk) (hz : z ∈ disk) :
    1+starRingEnd ℂ a*z ≠ 0 := by
  have hna : ‖a‖ < 1 := by simpa [disk] using ha
  have hnz : ‖z‖ < 1 := by simpa [disk] using hz
  intro he
  have hb : ‖starRingEnd ℂ a*z‖ < 1 := by
    rw [norm_mul,Complex.norm_conj]
    nlinarith [norm_nonneg a,norm_nonneg z]
  have he' : starRingEnd ℂ a*z = -1 := by linear_combination he
  rw [he'] at hb
  norm_num at hb

lemma diskAutomorphism_normSq_identity (a z : ℂ) :
    Complex.normSq (1+starRingEnd ℂ a*z)-Complex.normSq (z+a) =
      (1-Complex.normSq a)*(1-Complex.normSq z) := by
  simp [Complex.normSq, Complex.mul_re, Complex.mul_im]
  ring

lemma diskAutomorphism_mem {a z : ℂ} (ha : a ∈ disk) (hz : z ∈ disk) :
    diskAutomorphism a z ∈ disk := by
  have hna : ‖a‖ < 1 := by simpa [disk] using ha
  have hnz : ‖z‖ < 1 := by simpa [disk] using hz
  have hpos : 0 < (1-Complex.normSq a)*(1-Complex.normSq z) := by
    rw [← Complex.sq_norm, ← Complex.sq_norm]
    apply mul_pos <;> nlinarith [norm_nonneg a,norm_nonneg z]
  have hineq := diskAutomorphism_normSq_identity a z
  have hd := diskAutomorphism_den_ne_zero ha hz
  rw [disk,Metric.mem_ball,dist_zero_right,diskAutomorphism,norm_div,div_lt_one (norm_pos_iff.mpr hd)]
  rw [← Complex.sq_norm,← Complex.sq_norm] at hineq
  nlinarith [norm_nonneg (z+a),norm_nonneg (1+starRingEnd ℂ a*z)]

lemma diskAutomorphism_deriv {a z : ℂ} (ha : a ∈ disk) (hz : z ∈ disk) :
    HasDerivAt (diskAutomorphism a)
      ((1-(‖a‖^2 : ℝ))/(1+starRingEnd ℂ a*z)^2) z := by
  have hd := ((hasDerivAt_id z).add_const a).div
    (((hasDerivAt_id z).const_mul (starRingEnd ℂ a)).const_add 1)
    (diskAutomorphism_den_ne_zero ha hz)
  convert hd using 1 <;> try rfl
  rw [Complex.sq_norm]
  rw [Complex.normSq_eq_conj_mul_self]
  simp only [id_eq]
  ring

lemma diskAutomorphism_injOn {a : ℂ} (ha : a ∈ disk) : InjOn (diskAutomorphism a) disk := by
  intro z hz w hw he
  have he' := (div_eq_div_iff (diskAutomorphism_den_ne_zero ha hz)
    (diskAutomorphism_den_ne_zero ha hw)).mp he
  have hna : ‖a‖ < 1 := by simpa [disk] using ha
  have hd : (1-starRingEnd ℂ a*a) ≠ 0 := by
    rw [← Complex.normSq_eq_conj_mul_self,← Complex.ofReal_one,← Complex.ofReal_sub]
    apply Complex.ofReal_ne_zero.mpr
    rw [← Complex.sq_norm]
    nlinarith [norm_nonneg a]
  apply (mul_left_cancel₀ hd)
  linear_combination he'

lemma diskAutomorphism_zero (a : ℂ) : diskAutomorphism a 0 = a := by simp [diskAutomorphism]

lemma diskAutomorphism_differentiableOn {a : ℂ} (ha : a ∈ disk) :
    DifferentiableOn ℂ (diskAutomorphism a) disk :=
  fun _ hz => (diskAutomorphism_deriv ha hz).differentiableAt.differentiableWithinAt

lemma diskAutomorphism_second_deriv {a : ℂ} (ha : a ∈ disk) :
    deriv (deriv (diskAutomorphism a)) 0 =
      -2*starRingEnd ℂ a*(1-(‖a‖^2 : ℝ)) := by
  have hzero : (0 : ℂ) ∈ disk := by simp [disk]
  have he : deriv (diskAutomorphism a) =ᶠ[𝓝 (0 : ℂ)]
      fun z => (1-(‖a‖^2 : ℝ))/(1+starRingEnd ℂ a*z)^2 := by
    filter_upwards [Metric.isOpen_ball.mem_nhds hzero] with z hz
    exact (diskAutomorphism_deriv ha hz).deriv
  have hd := (hasDerivAt_const (0 : ℂ) (1-((‖a‖^2 : ℝ) : ℂ))).div
    ((((hasDerivAt_id (0 : ℂ)).const_mul (starRingEnd ℂ a)).const_add 1).pow 2)
    (by simp)
  have hd' := hd.congr_of_eventuallyEq he
  rw [hd'.deriv]
  simp
  ring

def diskKoebe (f : ℂ → ℂ) (a z : ℂ) : ℂ :=
  (f (diskAutomorphism a z)-f a)/((1-((‖a‖^2 : ℝ) : ℂ))*deriv f a)

lemma disk_coeff_ne_zero {a : ℂ} (ha : a ∈ disk) : 1-((‖a‖^2 : ℝ) : ℂ) ≠ 0 := by
  have hn : ‖a‖ < 1 := by simpa [disk] using ha
  rw [← Complex.ofReal_one,← Complex.ofReal_sub,Complex.ofReal_ne_zero]
  nlinarith [norm_nonneg a]

lemma diskKoebe_univalent {f : ℂ → ℂ} {a : ℂ} (hf : UnivalentOn f disk)
    (ha : a ∈ disk) (hfd : deriv f a ≠ 0) : UnivalentOn (diskKoebe f a) disk := by
  refine ⟨?_,?_⟩
  · exact ((hf.1.comp (diskAutomorphism_differentiableOn ha)
      (fun _ hz => diskAutomorphism_mem ha hz)).sub_const (f a)).div_const _
  · intro z hz w hw he
    have he' := (div_left_inj' (mul_ne_zero (disk_coeff_ne_zero ha) hfd)).mp he
    exact diskAutomorphism_injOn ha hz hw
      (hf.2 (diskAutomorphism_mem ha hz) (diskAutomorphism_mem ha hw) (sub_left_inj.mp he'))

lemma diskKoebe_deriv {f : ℂ → ℂ} {a z : ℂ} (hf : DifferentiableOn ℂ f disk)
    (ha : a ∈ disk) (hz : z ∈ disk) :
    HasDerivAt (diskKoebe f a)
      ((deriv f (diskAutomorphism a z)*((1-((‖a‖^2 : ℝ) : ℂ))/(1+starRingEnd ℂ a*z)^2))/
        ((1-((‖a‖^2 : ℝ) : ℂ))*deriv f a)) z := by
  exact ((((hf _ (diskAutomorphism_mem ha hz)).differentiableAt
    (Metric.isOpen_ball.mem_nhds (diskAutomorphism_mem ha hz))).hasDerivAt.comp z
    (diskAutomorphism_deriv ha hz)).sub_const (f a)).div_const _

lemma diskKoebe_schlicht {f : ℂ → ℂ} {a : ℂ} (hf : UnivalentOn f disk)
    (ha : a ∈ disk) (hfd : deriv f a ≠ 0) : Schlicht (diskKoebe f a) := by
  refine ⟨diskKoebe_univalent hf ha hfd, ?_, ?_⟩
  · simp [diskKoebe,diskAutomorphism_zero]
  · have hd := (diskKoebe_deriv hf.1 ha (by simp [disk] : (0 : ℂ) ∈ disk)).deriv
    rw [hd]
    simp only [diskAutomorphism_zero,mul_zero,add_zero,one_pow,div_one]
    rw [mul_comm (deriv f a),div_self (mul_ne_zero (disk_coeff_ne_zero ha) hfd)]

lemma diskKoebe_second_deriv {f : ℂ → ℂ} {a : ℂ} (hf : DifferentiableOn ℂ f disk)
    (ha : a ∈ disk) (hfd : deriv f a ≠ 0) :
    deriv (deriv (diskKoebe f a)) 0 =
      (1-((‖a‖^2 : ℝ) : ℂ))*deriv (deriv f) a/deriv f a-2*starRingEnd ℂ a := by
  have hzero : (0 : ℂ) ∈ disk := by simp [disk]
  have he : deriv (diskKoebe f a) =ᶠ[𝓝 (0 : ℂ)]
      fun z => (deriv f (diskAutomorphism a z)*
        ((1-((‖a‖^2 : ℝ) : ℂ))/(1+starRingEnd ℂ a*z)^2))/
        ((1-((‖a‖^2 : ℝ) : ℂ))*deriv f a) := by
    filter_upwards [Metric.isOpen_ball.mem_nhds hzero] with z hz
    exact (diskKoebe_deriv hf ha hz).deriv
  have hda := ((hf.deriv Metric.isOpen_ball a ha).differentiableAt
    (Metric.isOpen_ball.mem_nhds ha)).hasDerivAt
  have hda' : HasDerivAt (deriv f) (deriv (deriv f) a) (diskAutomorphism a 0) := by
    simpa [diskAutomorphism_zero] using hda
  have hcomp := hda'.comp 0 (diskAutomorphism_deriv ha hzero)
  have hrat := (hasDerivAt_const (0 : ℂ) (1-((‖a‖^2 : ℝ) : ℂ))).div
    ((((hasDerivAt_id (0 : ℂ)).const_mul (starRingEnd ℂ a)).const_add 1).pow 2)
    (by simp)
  have hd := ((hcomp.mul hrat).div_const
    ((1-((‖a‖^2 : ℝ) : ℂ))*deriv f a)).congr_of_eventuallyEq he
  rw [hd.deriv]
  simp only [Pi.div_apply,Pi.pow_apply,Function.comp_apply,diskAutomorphism_zero,
    mul_zero,add_zero,one_pow,div_one,zero_sub,id_eq,mul_one]
  have halg (A B C D : ℂ) (hB : B ≠ 0) (hC : C ≠ 0) :
      (A*C*C+B*(-(C*(2*D))))/(C*B) = C*A/B-2*D := by
    field_simp
    ring
  exact halg (deriv (deriv f) a) (deriv f a)
    (1-((‖a‖^2 : ℝ) : ℂ)) (starRingEnd ℂ a) hfd (disk_coeff_ne_zero ha)

def omittedTransform (f : ℂ → ℂ) (w z : ℂ) : ℂ := w*f z/(w-f z)

lemma omittedTransform_univalent {f : ℂ → ℂ} {w : ℂ}
    (hf : UnivalentOn f disk) (hw : w ∉ f '' disk) (hw0 : w ≠ 0) :
    UnivalentOn (omittedTransform f w) disk := by
  have hn (z) (hz : z ∈ disk) : w-f z ≠ 0 := by
    intro he
    exact hw ⟨z,hz,(sub_eq_zero.mp he).symm⟩
  refine ⟨(hf.1.const_mul w).div (hf.1.const_sub w) hn,?_⟩
  intro z hz v hv he
  apply hf.2 hz hv
  apply mul_left_cancel₀ (pow_ne_zero 2 hw0)
  have he' := (div_eq_div_iff (hn z hz) (hn v hv)).mp he
  linear_combination he'

lemma omittedTransform_deriv {f : ℂ → ℂ} {w z : ℂ}
    (hf : DifferentiableOn ℂ f disk) (hw : w ∉ f '' disk) (hz : z ∈ disk) :
    HasDerivAt (omittedTransform f w) (w^2*deriv f z/(w-f z)^2) z := by
  have hn : w-f z ≠ 0 := fun he => hw ⟨z,hz,(sub_eq_zero.mp he).symm⟩
  have hd := ((hf z hz).differentiableAt (Metric.isOpen_ball.mem_nhds hz)).hasDerivAt
  convert (hd.const_mul w).div (hd.const_sub w) hn using 1 <;> try rfl
  ring

lemma omittedTransform_schlicht {f : ℂ → ℂ} {w : ℂ}
    (hf : Schlicht f) (hw : w ∉ f '' disk) : Schlicht (omittedTransform f w) := by
  have hzero : (0 : ℂ) ∈ disk := by simp [disk]
  have hw0 : w ≠ 0 := fun h => hw ⟨0,hzero,hf.2.1.trans h.symm⟩
  refine ⟨omittedTransform_univalent hf.1 hw hw0,?_,?_⟩
  · simp [omittedTransform,hf.2.1]
  · rw [(omittedTransform_deriv hf.1.1 hw hzero).deriv,hf.2.1,hf.2.2]
    simp [hw0]

lemma omittedTransform_second_deriv {f : ℂ → ℂ} {w : ℂ}
    (hf : Schlicht f) (hw : w ∉ f '' disk) :
    deriv (deriv (omittedTransform f w)) 0 = deriv (deriv f) 0+2/w := by
  have hzero : (0 : ℂ) ∈ disk := by simp [disk]
  have hw0 : w ≠ 0 := fun h => hw ⟨0,hzero,hf.2.1.trans h.symm⟩
  have he : deriv (omittedTransform f w) =ᶠ[𝓝 (0 : ℂ)]
      fun z => w^2*deriv f z/(w-f z)^2 := by
    filter_upwards [Metric.isOpen_ball.mem_nhds hzero] with z hz
    exact (omittedTransform_deriv hf.1.1 hw hz).deriv
  have hfd := ((hf.1.1 0 hzero).differentiableAt (Metric.isOpen_ball.mem_nhds hzero)).hasDerivAt
  have hfdd := ((hf.1.1.deriv Metric.isOpen_ball 0 hzero).differentiableAt
    (Metric.isOpen_ball.mem_nhds hzero)).hasDerivAt
  have hd := ((hfdd.const_mul (w^2)).div ((hfd.const_sub w).pow 2)
    (by simpa [hf.2.1] using pow_ne_zero 2 hw0)).congr_of_eventuallyEq he
  rw [hd.deriv]
  simp only [Pi.pow_apply,hf.2.1,hf.2.2,sub_zero,mul_one]
  field_simp [hw0]
  ring

lemma schlicht_preSchwarzian_bound {f : ℂ → ℂ} (hf : Schlicht f) {a : ℂ} (ha : a ∈ disk) :
    ‖(1-((‖a‖^2 : ℝ) : ℂ))*deriv (deriv f) a/deriv f a-2*starRingEnd ℂ a‖ ≤ 4 := by
  have hn := univalent_deriv_ne_zero Metric.isOpen_ball hf.1 ha
  have hb := schlicht_second_deriv_bound (diskKoebe_schlicht hf.1 ha hn)
  rwa [diskKoebe_second_deriv hf.1.1 ha hn] at hb

lemma schlicht_quarter {f : ℂ → ℂ} (hf : Schlicht f) :
    Metric.ball (0 : ℂ) (1/4) ⊆ f '' disk := by
  intro w hw
  by_contra hnot
  have hz : (0 : ℂ) ∈ disk := by simp [disk]
  have hw0 : w ≠ 0 := fun h => hnot ⟨0,hz,hf.2.1.trans h.symm⟩
  have hb := schlicht_second_deriv_bound (omittedTransform_schlicht hf hnot)
  rw [omittedTransform_second_deriv hf hnot] at hb
  have hdiff : ‖(2 : ℂ)/w‖ ≤ 8 := by
    have ht := norm_sub_le (deriv (deriv f) 0+2/w) (deriv (deriv f) 0)
    have hf2 := schlicht_second_deriv_bound hf
    simp only [add_sub_cancel_left] at ht
    linarith
  rw [norm_div] at hdiff
  norm_num at hdiff
  have hle := (div_le_iff₀ (norm_pos_iff.mpr hw0)).mp hdiff
  have hw' : ‖w‖ < 1/4 := by simpa using hw
  linarith

lemma hasDerivAt_log_norm_real {g : ℝ → ℂ} {d : ℂ} {x : ℝ}
    (hg : HasDerivAt g d x) (hn : g x ≠ 0) :
    HasDerivAt (fun t => Real.log ‖g t‖) (d/g x).re x := by
  have heq : (fun t => Real.log ‖g t‖) =
      (fun t => (1/2 : ℝ)*Real.log (‖g t‖^2)) := by
    funext t
    rw [Real.log_pow]
    ring
  have hd := ((hg.norm_sq).log (pow_ne_zero 2 (norm_ne_zero_iff.mpr hn))).const_mul (1/2 : ℝ)
  rw [heq]
  convert hd using 1
  simp only [Complex.inner,Complex.conj_re,Complex.conj_im,Complex.mul_re,
    Complex.div_re,Complex.normSq_eq_norm_sq]
  ring

lemma logarithmic_distortion {L D : ℝ → ℝ} {r : ℝ} (hr : 0 ≤ r) (hr1 : r < 1)
    (hL : ∀ x ∈ Icc 0 r, HasDerivAt L (D x) x) (hL0 : L 0 = 0)
    (hbound : ∀ x ∈ Icc 0 r,
      (2*x-4)/(1-x^2) ≤ D x ∧ D x ≤ (2*x+4)/(1-x^2)) :
    Real.log (1-r)-3*Real.log (1+r) ≤ L r ∧
      L r ≤ Real.log (1+r)-3*Real.log (1-r) := by
  have hp (x : ℝ) (hx : x ∈ Icc 0 r) : 0 < 1-x ∧ 0 < 1+x ∧ 0 < 1-x^2 := by
    constructor
    · linarith [hx.2]
    constructor
    · linarith [hx.1]
    · have := hx.1
      nlinarith [hx.2]
  let U := fun x => L x-Real.log (1+x)+3*Real.log (1-x)
  let V := fun x => L x-Real.log (1-x)+3*Real.log (1+x)
  have hU (x) (hx : x ∈ Icc 0 r) : HasDerivAt U
      (D x-1/(1+x)-3/(1-x)) x := by
    have hlogp := ((hasDerivAt_id x).const_add 1).log (ne_of_gt (hp x hx).2.1)
    have hlogm := ((hasDerivAt_id x).const_sub 1).log (ne_of_gt (hp x hx).1)
    convert ((hL x hx).sub hlogp).add (hlogm.const_mul 3) using 1 <;> try rfl
    simp
    ring
  have hV (x) (hx : x ∈ Icc 0 r) : HasDerivAt V
      (D x+1/(1-x)+3/(1+x)) x := by
    have hlogp := ((hasDerivAt_id x).const_add 1).log (ne_of_gt (hp x hx).2.1)
    have hlogm := ((hasDerivAt_id x).const_sub 1).log (ne_of_gt (hp x hx).1)
    convert ((hL x hx).sub hlogm).add (hlogp.const_mul 3) using 1 <;> try rfl
    simp
    ring
  have halg (x) (hx : x ∈ Icc 0 r) :
      1/(1+x)+3/(1-x) = (2*x+4)/(1-x^2) ∧
      -(1/(1-x)+3/(1+x)) = (2*x-4)/(1-x^2) := by
    constructor <;> field_simp [(hp x hx).1.ne', (hp x hx).2.1.ne', (hp x hx).2.2.ne'] <;> ring
  have hUa : AntitoneOn U (Icc 0 r) := by
    apply antitoneOn_of_deriv_nonpos (convex_Icc 0 r)
      (fun x hx => (hU x hx).continuousAt.continuousWithinAt)
      (fun x hx => (hU x (interior_subset hx)).differentiableAt.differentiableWithinAt)
    intro x hx
    rw [(hU x (interior_subset hx)).deriv]
    have hb := (hbound x (interior_subset hx)).2
    rw [← (halg x (interior_subset hx)).1] at hb
    linarith
  have hVm : MonotoneOn V (Icc 0 r) := by
    apply monotoneOn_of_deriv_nonneg (convex_Icc 0 r)
      (fun x hx => (hV x hx).continuousAt.continuousWithinAt)
      (fun x hx => (hV x (interior_subset hx)).differentiableAt.differentiableWithinAt)
    intro x hx
    rw [(hV x (interior_subset hx)).deriv]
    have hb := (hbound x (interior_subset hx)).1
    rw [← (halg x (interior_subset hx)).2] at hb
    linarith
  have hu := hUa (left_mem_Icc.mpr hr) (right_mem_Icc.mpr hr) hr
  have hv := hVm (left_mem_Icc.mpr hr) (right_mem_Icc.mpr hr) hr
  dsimp [U,V] at hu hv
  simp only [hL0,add_zero,sub_zero,Real.log_one,mul_zero] at hu hv
  constructor <;> linarith

lemma radialDistortion_of_preSchwarzian {f : ℂ → ℂ}
    (hf : DifferentiableOn ℂ f disk) (hf0 : deriv f 0 = 1)
    (hfn : ∀ a ∈ disk, deriv f a ≠ 0)
    (hps : ∀ a ∈ disk,
      ‖(1-((‖a‖^2 : ℝ) : ℂ))*deriv (deriv f) a/deriv f a-2*starRingEnd ℂ a‖ ≤ 4)
    {r : ℝ} (hr : 0 ≤ r) (hr1 : r < 1) {ζ : ℂ} (hζ : ‖ζ‖ = 1) :
    (1-r)/(1+r)^3 ≤ ‖deriv f ((r : ℂ)*ζ)‖ ∧
      ‖deriv f ((r : ℂ)*ζ)‖ ≤ (1+r)/(1-r)^3 := by
  let L : ℝ → ℝ := fun x => Real.log ‖deriv f ((x : ℂ)*ζ)‖
  let D : ℝ → ℝ := fun x => (deriv (deriv f) ((x : ℂ)*ζ)*ζ/deriv f ((x : ℂ)*ζ)).re
  have hn (x) (hx : x ∈ Icc 0 r) : ‖(x : ℂ)*ζ‖ = x := by
    rw [norm_mul,hζ,mul_one,Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg hx.1]
  have hm (x) (hx : x ∈ Icc 0 r) : (x : ℂ)*ζ ∈ disk := by
    simp only [disk,Metric.mem_ball,dist_zero_right,hn x hx]
    exact hx.2.trans_lt hr1
  have hD (x) (hx : x ∈ Icc 0 r) : HasDerivAt L (D x) x := by
    have hd := ((hf.deriv Metric.isOpen_ball _ (hm x hx)).differentiableAt
      (Metric.isOpen_ball.mem_nhds (hm x hx))).hasDerivAt
    have hx' : HasDerivAt (fun t : ℝ => (t : ℂ)*ζ) ζ x := by
      simpa using (Complex.ofRealCLM.hasDerivAt.mul_const ζ :
        HasDerivAt (fun t : ℝ => Complex.ofRealCLM t*ζ) ((Complex.ofRealCLM (1 : ℝ))*ζ) x)
    have hdc : HasDerivAt (fun t : ℝ => deriv f ((t : ℂ)*ζ))
        (deriv (deriv f) ((x : ℂ)*ζ)*ζ) x := by
      convert HasDerivAt.comp (𝕜 := ℝ) x hd hx' using 1
      rfl
    exact hasDerivAt_log_norm_real hdc (hfn _ (hm x hx))
  have hb (x) (hx : x ∈ Icc 0 r) :
      (2*x-4)/(1-x^2) ≤ D x ∧ D x ≤ (2*x+4)/(1-x^2) := by
    let A : ℂ := (1-((x^2 : ℝ) : ℂ))*deriv (deriv f) ((x : ℂ)*ζ)/deriv f ((x : ℂ)*ζ)
      -2*starRingEnd ℂ ((x : ℂ)*ζ)
    have hA : ‖A*ζ‖ ≤ 4 := by
      rw [norm_mul,hζ,mul_one]
      simpa only [A,hn x hx] using hps _ (hm x hx)
    have he : (A*ζ).re = (1-x^2)*D x-2*x := by
      have hzz : starRingEnd ℂ ζ*ζ = 1 := by
        rw [← Complex.normSq_eq_conj_mul_self,← Complex.sq_norm,hζ]
        norm_num
      have heq : A*ζ = ((1-x^2 : ℝ) : ℂ)*
          (deriv (deriv f) ((x : ℂ)*ζ)*ζ/deriv f ((x : ℂ)*ζ))-2*(x : ℂ) := by
        dsimp only [A]
        rw [map_mul,Complex.conj_ofReal]
        rw [Complex.ofReal_sub,Complex.ofReal_one]
        linear_combination -2*(x : ℂ)*hzz
      rw [heq]
      simp only [D,Complex.sub_re,Complex.mul_re,Complex.ofReal_re,Complex.ofReal_im,
        zero_mul,sub_zero]
      norm_num
    have hreal := (Complex.abs_re_le_norm (A*ζ)).trans hA
    rw [he,abs_le] at hreal
    have hpos : 0 < 1-x^2 := by nlinarith [hx.1,hx.2]
    constructor
    · rw [div_le_iff₀ hpos]
      nlinarith [hreal.1]
    · rw [le_div_iff₀ hpos]
      nlinarith [hreal.2]
  have hbnd := logarithmic_distortion hr hr1 hD (by simp [L,hf0]) hb
  have hposm : 0 < 1-r := sub_pos.mpr hr1
  have hposp : 0 < 1+r := by linarith
  have hnorm : 0 < ‖deriv f ((r : ℂ)*ζ)‖ := norm_pos_iff.mpr (hfn _ (hm r (right_mem_Icc.mpr hr)))
  constructor
  · apply (Real.log_le_log_iff (div_pos hposm (pow_pos hposp 3)) hnorm).mp
    simpa only [Real.log_div hposm.ne' (pow_ne_zero 3 hposp.ne'),Real.log_pow,Nat.cast_ofNat] using hbnd.1
  · apply (Real.log_le_log_iff hnorm (div_pos hposp (pow_pos hposm 3))).mp
    simpa only [Real.log_div hposp.ne' (pow_ne_zero 3 hposm.ne'),Real.log_pow,Nat.cast_ofNat] using hbnd.2

lemma schlicht_deriv_bounds {f : ℂ → ℂ} (hf : Schlicht f) {z : ℂ} (hz : z ∈ disk) :
    (1-‖z‖)/(1+‖z‖)^3 ≤ ‖deriv f z‖ ∧
      ‖deriv f z‖ ≤ (1+‖z‖)/(1-‖z‖)^3 := by
  by_cases hzero : z = 0
  · simp [hzero,hf.2.2]
  have hn := norm_pos_iff.mpr hzero
  have hζ : ‖z/(‖z‖ : ℂ)‖ = 1 := by
    rw [norm_div,Complex.norm_real,Real.norm_eq_abs,abs_of_nonneg (norm_nonneg z),div_self hn.ne']
  have heq : (‖z‖ : ℂ)*(z/(‖z‖ : ℂ)) = z := by
    field_simp [show (‖z‖ : ℂ) ≠ 0 by exact_mod_cast hn.ne']
  have hb := radialDistortion_of_preSchwarzian hf.1.1 hf.2.2
    (fun _ ha => univalent_deriv_ne_zero Metric.isOpen_ball hf.1 ha)
    (fun _ ha => schlicht_preSchwarzian_bound hf ha) (norm_nonneg z)
    (show ‖z‖ < 1 by simpa [disk] using hz) hζ
  rwa [heq] at hb

lemma schlicht_deriv_compact_bound {f : ℂ → ℂ} (hf : Schlicht f)
    {R : ℝ} (hR : R < 1) {z : ℂ} (hz : ‖z‖ ≤ R) :
    ‖deriv f z‖ ≤ 2/(1-R)^3 := by
  have hzm : z ∈ disk := by simpa [disk] using hz.trans_lt hR
  apply (schlicht_deriv_bounds hf hzm).2.trans
  have hd : 0 < 1-R := sub_pos.mpr hR
  apply div_le_div₀ (by positivity) (by linarith [norm_nonneg z]) (by positivity)
  exact pow_le_pow_left₀ hd.le (by linarith) 3

lemma schlicht_lipschitz_bound {f : ℂ → ℂ} (hf : Schlicht f)
    {R : ℝ} (hR : R < 1) {z w : ℂ} (hz : ‖z‖ ≤ R) (hw : ‖w‖ ≤ R) :
    ‖f z-f w‖ ≤ (2/(1-R)^3)*‖z-w‖ := by
  apply Convex.norm_image_sub_le_of_norm_deriv_le (s := Metric.closedBall 0 R)
    (𝕜 := ℂ) _ _ (convex_closedBall 0 R)
    (by simpa using hw) (by simpa using hz)
  · intro x hx
    apply (hf.1.1 x _).differentiableAt
      (Metric.isOpen_ball.mem_nhds (show x ∈ disk from ?_))
    all_goals simpa [disk] using (show ‖x‖ ≤ R by simpa using hx).trans_lt hR
  · intro x hx
    exact schlicht_deriv_compact_bound hf hR (by simpa using hx)

lemma schlicht_local_bound {f : ℂ → ℂ} (hf : Schlicht f)
    {R : ℝ} (hR : R < 1) {z : ℂ} (hz : ‖z‖ ≤ R) :
    ‖f z‖ ≤ (2/(1-R)^3)*R := by
  have h := schlicht_lipschitz_bound hf hR hz
    (show ‖(0 : ℂ)‖ ≤ R by simpa using (norm_nonneg z).trans hz)
  simp only [hf.2.1,sub_zero] at h
  exact h.trans (mul_le_mul_of_nonneg_left hz (by positivity))

def ballNormalize (f : ℂ → ℂ) (a : ℂ) (R : ℝ) (z : ℂ) : ℂ :=
  (f (a+(R : ℂ)*z)-f a)/((R : ℂ)*deriv f a)

lemma affine_disk_maps_ball (a : ℂ) {R : ℝ} (hR : 0 < R) :
    MapsTo (fun z : ℂ => a+(R : ℂ)*z) disk (Metric.ball a R) := by
  intro z hz
  have hz' : ‖z‖ < 1 := by simpa [disk] using hz
  simp only [Metric.mem_ball,dist_eq_norm,add_sub_cancel_left,norm_mul,
    Complex.norm_real,Real.norm_eq_abs,abs_of_pos hR]
  nlinarith

lemma ballNormalize_deriv {f : ℂ → ℂ} {a z : ℂ} {R : ℝ} (hR : 0 < R)
    (hf : DifferentiableOn ℂ f (Metric.ball a R)) (hz : z ∈ disk) :
    HasDerivAt (ballNormalize f a R)
      (deriv f (a+(R : ℂ)*z)/deriv f a) z := by
  have hmap := affine_disk_maps_ball a hR hz
  have hd := ((hf _ hmap).differentiableAt (Metric.isOpen_ball.mem_nhds hmap)).hasDerivAt
  have hdz := (((hd.comp z (((hasDerivAt_id z).const_mul (R : ℂ)).const_add a)).sub_const (f a)).div_const
    ((R : ℂ)*deriv f a))
  convert hdz using 1 <;> try rfl
  have hRc : (R : ℂ) ≠ 0 := by exact_mod_cast hR.ne'
  simp only [mul_one]
  field_simp

lemma ballNormalize_schlicht {f : ℂ → ℂ} {a : ℂ} {R : ℝ} (hR : 0 < R)
    (hf : UnivalentOn f (Metric.ball a R)) (hn : deriv f a ≠ 0) :
    Schlicht (ballNormalize f a R) := by
  have hRc : (R : ℂ) ≠ 0 := by exact_mod_cast hR.ne'
  have hmap := affine_disk_maps_ball a hR
  refine ⟨⟨?_,?_⟩,?_,?_⟩
  · intro z hz
    exact (ballNormalize_deriv hR hf.1 hz).differentiableAt.differentiableWithinAt
  · intro z hz w hw he
    apply mul_left_cancel₀ hRc
    apply add_left_cancel (a := a)
    apply hf.2 (hmap hz) (hmap hw)
    have he' := (div_left_inj' (mul_ne_zero hRc hn)).mp he
    exact sub_left_inj.mp he'
  · simp [ballNormalize]
  · rw [(ballNormalize_deriv hR hf.1 (show (0 : ℂ) ∈ disk by simp [disk])).deriv]
    simp [hn]

lemma univalent_ball_quarter {f : ℂ → ℂ} {a : ℂ} {R : ℝ} (hR : 0 < R)
    (hf : UnivalentOn f (Metric.ball a R)) :
    Metric.ball (f a) (R*‖deriv f a‖/4) ⊆ f '' Metric.ball a R := by
  have ha : a ∈ Metric.ball a R := Metric.mem_ball_self hR
  have hn := univalent_deriv_ne_zero Metric.isOpen_ball hf ha
  have hRc : (R : ℂ) ≠ 0 := by exact_mod_cast hR.ne'
  have hden := mul_ne_zero hRc hn
  intro w hw
  have hu : (w-f a)/((R : ℂ)*deriv f a) ∈ Metric.ball (0 : ℂ) (1/4) := by
    simp only [Metric.mem_ball,dist_zero_right,norm_div,norm_mul,
      Complex.norm_real,Real.norm_eq_abs,abs_of_pos hR]
    rw [div_lt_iff₀ (mul_pos hR (norm_pos_iff.mpr hn))]
    have hw' : ‖w-f a‖ < R*‖deriv f a‖/4 := by simpa [dist_eq_norm] using hw
    linarith
  obtain ⟨z,hz,he⟩ := schlicht_quarter (ballNormalize_schlicht hR hf hn) hu
  refine ⟨a+(R : ℂ)*z,affine_disk_maps_ball a hR hz,?_⟩
  have hes := (div_left_inj' hden).mp he
  exact sub_left_inj.mp hes

lemma schlicht_separation {f : ℂ → ℂ} (hf : Schlicht f)
    {z w : ℂ} (_hz : z ∈ disk) (hw : w ∈ disk) {R : ℝ} (hR : 0 < R)
    (hsub : Metric.ball z R ⊆ disk) (hdist : R ≤ ‖w-z‖) :
    R*‖deriv f z‖/4 ≤ ‖f w-f z‖ := by
  by_contra! hlt
  have hm : f w ∈ Metric.ball (f z) (R*‖deriv f z‖/4) := by
    simpa [dist_eq_norm] using hlt
  obtain ⟨v,hv,he⟩ := univalent_ball_quarter hR ⟨hf.1.1.mono hsub,hf.1.2.mono hsub⟩ hm
  have hvw := hf.1.2 (hsub hv) hw he
  subst v
  have : ‖w-z‖ < R := by simpa [dist_eq_norm] using hv
  exact (not_lt_of_ge hdist) this

lemma schlicht_lower_growth {f : ℂ → ℂ} (hf : Schlicht f) {z : ℂ} (hz : z ∈ disk) :
    ‖z‖/4 ≤ ‖f z‖ := by
  by_cases hzero : z = 0
  · simp [hzero,hf.2.1]
  have h := schlicht_separation hf (show (0 : ℂ) ∈ disk by simp [disk]) hz
    (norm_pos_iff.mpr hzero)
    (Metric.ball_subset_ball (show ‖z‖ ≤ 1 by exact le_of_lt (by simpa [disk] using hz)))
    (show ‖z‖ ≤ ‖z-(0 : ℂ)‖ by simp)
  simpa [hf.2.1,hf.2.2] using h

lemma schlicht_uniform_separation {z w : ℂ} (hz : z ∈ disk) (hw : w ∈ disk)
    (hne : z ≠ w) : ∃ c : ℝ, 0 < c ∧ ∀ f : ℂ → ℂ, Schlicht f → c ≤ ‖f w-f z‖ := by
  have hz1 : ‖z‖ < 1 := by simpa [disk] using hz
  let R := min ((1-‖z‖)/2) (‖w-z‖/2)
  have hR : 0 < R := lt_min (by linarith)
    (div_pos (norm_pos_iff.mpr (sub_ne_zero.mpr hne.symm)) (by norm_num))
  have hR1 : R ≤ (1-‖z‖)/2 := min_le_left _ _
  have hR2 : R ≤ ‖w-z‖/2 := min_le_right _ _
  have hsub : Metric.ball z R ⊆ disk := by
    intro v hv
    have hvR : ‖v-z‖ < R := by simpa [dist_eq_norm] using hv
    have ht := norm_add_le (v-z) z
    rw [sub_add_cancel] at ht
    simp only [disk,Metric.mem_ball,dist_zero_right]
    linarith
  refine ⟨R*((1-‖z‖)/(1+‖z‖)^3)/4,by positivity,?_⟩
  intro f hf
  have h := schlicht_separation hf hz hw hR hsub (by linarith [norm_nonneg (w-z)])
  apply le_trans _ h
  exact div_le_div_of_nonneg_right (mul_le_mul_of_nonneg_left (schlicht_deriv_bounds hf hz).1 hR.le)
    (by norm_num)

end Brennan

end

end OAI