/-
Portions of this file have been adapted from an external source.
The source copyright header and license information are preserved below.
-/

import OAI.Analysis.DirectCrouzeix.NormalFamilies

namespace OAI

noncomputable section

open scoped Matrix Matrix.Norms.L2Operator Kronecker

noncomputable section

open MeasureTheory Set Filter Metric

open scoped Topology Interval ENNReal NNReal ComplexConjugate

noncomputable section

open Filter Metric Set

open scoped Topology ComplexConjugate

namespace DirectCrouzeix

namespace Conformal

open Function Complex

open scoped Pointwise

/-
Copyright (c) 2026 Yury Kudryashov. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Yury Kudryashov

The following conformal embedding declarations are adapted from Mathlib.Analysis.Complex.RiemannMapping.
Source: https://github.com/leanprover-community/mathlib4/blob/d13f23b723b8a846827a245b89c10fc7d3f11612/Mathlib/Analysis/Complex/RiemannMapping.lean

This code has been modified.
-/

theorem exists_injective_not_dense_image_deriv_ne_zero {U : Set ℂ} (hUo : IsOpen U)
    (hUc : IsSimplyConnected U) (hU : U ≠ univ) :
    ∃ f : ℂ → ℂ, Injective f ∧ ¬Dense (f '' U) ∧ ∀ z ∈ U, deriv f z ≠ 0 := by

  wlog hU₀ : 0 ∉ U
  · rw [ne_univ_iff_exists_notMem] at hU
    rcases hU with ⟨a, ha⟩
    specialize this (hUo.vadd (-a)) (by simpa) (by simp [hU])
      (by simpa [mem_vadd_set_iff_neg_vadd_mem])
    rcases this with ⟨f, hf_inj, hf_dense, hdf⟩
    refine ⟨f ∘ (-a + ·), hf_inj.comp (add_right_injective (-a)), ?_, fun z hz ↦ ?_⟩
    · simpa only [← image_vadd, Set.image_image] using! hf_dense
    · simpa [Function.comp_def, deriv_comp_const_add] using hdf (-a + z) (mapsTo_image _ _ hz)

  rcases exists_continuousOn_pow_eq hUc hUo continuousOn_id (by rwa [image_id]) two_ne_zero
    with ⟨f, hfc, hf_inv⟩
  replace hf_inv : LeftInverse (· ^ 2) f := hf_inv

  have hf₀ : ∀ z ∈ U, f z ≠ 0 := by
    intro z hz hfz
    simpa [hfz, (ne_of_mem_of_not_mem hz hU₀).symm] using hf_inv z

  have hdf : ∀ z ∈ U, HasStrictDerivAt f (2 * f z)⁻¹ z := by
    intro z hz
    apply HasStrictDerivAt.of_local_left_inverse
    · exact hfc.continuousAt <| hUo.mem_nhds hz
    · simpa using hasStrictDerivAt_pow 2 (f z)
    · simpa using hf₀ z hz
    · exact .of_forall hf_inv

  refine ⟨f, hf_inv.injective, ?_, fun z hz ↦ ?_⟩
  ·
    simp only [Dense, not_forall, mem_closure_iff_frequently, not_frequently]
    rcases hUc.nonempty with ⟨x, hx⟩

    use -f x

    have : f '' U ∈ 𝓝 (f x) := by
      rw [← (hdf x hx).map_nhds_eq (by simpa using hf₀ x hx)]
      exact Filter.image_mem_map <| hUo.mem_nhds hx

    rw [nhds_neg, eventually_neg]

    filter_upwards [this]
    rintro _ ⟨a, ha, rfl⟩ ⟨b, hb, hab⟩
    obtain rfl : a = b := by
      rw [← hf_inv b, hab]
      simp [hf_inv a]
    refine hf₀ a ha ?_
    linear_combination hab / 2
  · simpa [(hdf z hz).hasDerivAt.deriv] using hf₀ z hz

lemma exists_mapsTo_unitBall_injOn_deriv_ne_zero {U : Set ℂ} (hUo : IsOpen U)
    (hUc : IsSimplyConnected U) (hU : U ≠ univ) :
    ∃ f : ℂ → ℂ, MapsTo f U (ball 0 1) ∧ InjOn f U ∧ ∀ z ∈ U, deriv f z ≠ 0 := by

  rcases exists_injective_not_dense_image_deriv_ne_zero hUo hUc hU with ⟨f, hf_inj, hfd, hdf⟩

  obtain ⟨x, ε, hε₀, hε⟩ : ∃ (x : ℂ) (ε : ℝ), 0 < ε ∧ ∀ a ∈ U, ε < dist (f a) x := by
    simpa [Dense, mem_closure_iff_nhds_basis Metric.nhds_basis_closedBall] using hfd
  have hfx : ∀ z ∈ U, f z ≠ x := fun z hz ↦ by simpa using hε₀.trans (hε z hz)

  use fun z ↦ ε / (f z - x)
  refine ⟨?mapsTo, ?injOn, ?deriv⟩
  case mapsTo =>
    intro z hz
    rw [mem_ball_zero_iff, norm_div, norm_real, Real.norm_of_nonneg hε₀.le, div_lt_one₀]
    · simpa [dist_eq_norm] using hε z hz
    · simpa [sub_eq_zero] using hfx z hz
  case injOn =>
    intro z hz w hw heq
    simpa [div_eq_mul_inv, hε₀.ne', hf_inj.eq_iff] using heq
  case deriv =>
    intro z hz
    have hdz : DifferentiableAt ℂ f z := differentiableAt_of_deriv_ne_zero (hdf z hz)
    rw [(hasDerivAt_const _ _).fun_div (hdz.hasDerivAt.sub_const _) _ |>.deriv] <;>
      simp [*, ne_of_gt, sub_eq_zero]

structure NormalizedEmbedding (U : Set ℂ) (a : ℂ) (f : ℂ → ℂ) : Prop where
  holomorphic : DifferentiableOn ℂ f U
  disk : MapsTo f U (ball 0 1)
  injective : InjOn f U
  derivative : ∀ z ∈ U, deriv f z ≠ 0
  normalized : f a = 0

theorem exists_normalizedEmbedding {U : Set ℂ} (hU : IsOpen U)
    (hUc : IsSimplyConnected U) (hproper : U ≠ univ) {a : ℂ} (ha : a ∈ U) :
    ∃ f, NormalizedEmbedding U a f := by
  obtain ⟨e, hed, hei, he'⟩ :=
    exists_mapsTo_unitBall_injOn_deriv_ne_zero hU hUc hproper
  have he : DifferentiableOn ℂ e U := fun z hz =>
    (differentiableAt_of_deriv_ne_zero (he' z hz)).differentiableWithinAt
  let f : ℂ → ℂ := fun z => (e z - e a) / 2
  have hf' (z : ℂ) (hz : z ∈ U) : HasDerivAt f (deriv e z / 2) z :=
    ((he.hasDerivAt (hU.mem_nhds hz)).sub_const _).div_const _
  refine ⟨f, ⟨he.sub_const _ |>.div_const _, ?_, ?_, ?_, by simp [f]⟩⟩
  · intro z hz
    rw [mem_ball_zero_iff]
    dsimp [f]
    rw [norm_div]
    norm_num
    have h1 := norm_sub_le (e z) (e a)
    have h2 : ‖e z‖ < 1 := mem_ball_zero_iff.mp (hed hz)
    have h3 : ‖e a‖ < 1 := mem_ball_zero_iff.mp (hed ha)
    linarith
  · intro z hz w hw heq
    apply hei hz hw
    dsimp [f] at heq
    exact sub_left_injective ((div_left_inj' (by norm_num : (2 : ℂ) ≠ 0)).mp heq)
  · intro z hz
    rw [(hf' z hz).deriv]
    exact div_ne_zero (he' z hz) (by norm_num)

theorem extend_restrict_eventuallyEq {U : Set ℂ} (hU : IsOpen U)
    {f : ℂ → ℂ} {a : ℂ} (ha : a ∈ U) :
    extend U (fun z : U => f z) =ᶠ[𝓝 a] f := by
  filter_upwards [hU.mem_nhds ha] with z hz
  simp [extend, hz]

theorem exists_extremalEmbedding {U : Set ℂ} (hU : IsOpen U)
    (hUc : IsSimplyConnected U) (hproper : U ≠ univ) {a : ℂ} (ha : a ∈ U) :
    ∃ f, NormalizedEmbedding U a f ∧
      ∀ g, NormalizedEmbedding U a g → ‖deriv g a‖ ≤ ‖deriv f a‖ := by
  let : LocallyCompactSpace U := hU.locallyCompactSpace
  let S : Set C(U, ℂ) := {f | NormalizedEmbedding U a (extend U f)}
  have hS : ∀ f ∈ S, DifferentiableOn ℂ (extend U f) U ∧ ∀ z : U, ‖f z‖ ≤ 1 := by
    intro f hf
    refine ⟨hf.holomorphic, fun z => ?_⟩
    simpa only [extend_coe] using (mem_ball_zero_iff.mp (hf.disk z.property)).le
  have hCS := bounded_holomorphic_compact hU S hS
  have hLS (g : C(U, ℂ)) (hg : g ∈ closure S) := bounded_holomorphic_closure hU hS hg
  have hmk (f : ℂ → ℂ) (hf : NormalizedEmbedding U a f) :
      (⟨fun z : U => f z, hf.holomorphic.continuousOn.domRestrict⟩ : C(U, ℂ)) ∈ S := by
    let g : C(U, ℂ) := ⟨fun z : U => f z, hf.holomorphic.continuousOn.domRestrict⟩
    have heq (z : ℂ) (hz : z ∈ U) : extend U g =ᶠ[𝓝 z] f :=
      extend_restrict_eventuallyEq hU hz
    change NormalizedEmbedding U a (extend U g)
    refine ⟨?_, ?_, ?_, ?_, ?_⟩
    · intro z hz
      exact ((hf.holomorphic.differentiableAt (hU.mem_nhds hz)).congr_of_eventuallyEq
        (heq z hz)).differentiableWithinAt
    · intro z hz
      rw [(heq z hz).self_of_nhds]
      exact hf.disk hz
    · intro z hz w hw he
      apply hf.injective hz hw
      rwa [(heq z hz).self_of_nhds, (heq w hw).self_of_nhds] at he
    · intro z hz
      rw [(heq z hz).deriv_eq]
      exact hf.derivative z hz
    · rw [(heq a ha).self_of_nhds]
      exact hf.normalized
  obtain ⟨f₀, hf₀⟩ := exists_normalizedEmbedding hU hUc hproper ha
  let F₀ : C(U, ℂ) := ⟨fun z : U => f₀ z, hf₀.holomorphic.continuousOn.domRestrict⟩
  have hF₀ : F₀ ∈ S := hmk _ hf₀
  obtain ⟨g, hg, hmax⟩ := hCS.exists_isMaxOn ⟨F₀, subset_closure hF₀⟩
    (derivative_continuousOn hU (fun f hf => (hLS _ hf).1) ha).norm
  have hpos : 0 < ‖deriv (extend U g) a‖ :=
    (norm_pos_iff.mpr (hF₀.derivative a ha)).trans_le (hmax (subset_closure hF₀))
  obtain ⟨F, hF, hl⟩ := mem_closure_iff_seq_limit.mp hg
  have hlu := continuousMap_limit hU hl
  have hd := (hLS _ hg).1
  have hn : extend U g a = 0 := by
    exact tendsto_nhds_unique (hlu.tendsto_at ha)
      (by simpa only [(hF _).normalized] using tendsto_const_nhds (x := (0 : ℂ)))
  have hi : InjOn (extend U g) U := by
    apply (constant_or_injective_limit hU hUc.isPathConnected.isConnected.isPreconnected
      (fun n => (hF n).holomorphic) (fun n => (hF n).injective) hlu).resolve_left
    rintro ⟨c, hc⟩
    have he : extend U g =ᶠ[𝓝 a] (fun _ => c) := by
      filter_upwards [hU.mem_nhds ha] with z hz
      exact hc hz
    have hz := he.deriv_eq
    simp only [deriv_const] at hz
    exact (ne_of_gt hpos) (by rw [hz, norm_zero])
  have hder : ∀ z ∈ U, deriv (extend U g) z ≠ 0 := by
    have hdl := hlu.deriv (Eventually.of_forall (fun n => (hF n).holomorphic)) hU
    apply (zero_or_nonvanishing_limit hU hUc.isPathConnected.isConnected.isPreconnected
      (fun n => ((hF n).holomorphic.analyticOnNhd hU).deriv.differentiableOn)
      (fun n => (hF n).derivative) hdl).resolve_left
    intro he
    exact (ne_of_gt hpos) (by rw [he ha, Pi.zero_apply, norm_zero])
  have hgN : NormalizedEmbedding U a (extend U g) :=
    ⟨hd, strict_bound_of_normalized hU hUc.isPathConnected.isConnected.isPreconnected hd
      (fun z hz => by simpa [extend, hz] using (hLS _ hg).2 ⟨z, hz⟩) ha hn, hi, hder, hn⟩
  refine ⟨extend U g, hgN, fun f hf => ?_⟩
  have hm := hmax (subset_closure (hmk f hf))
  change ‖deriv (extend U (fun z : U => f z)) a‖ ≤ _ at hm
  rwa [(extend_restrict_eventuallyEq hU ha).deriv_eq] at hm

end Conformal

end DirectCrouzeix

end

end

end

end OAI