Update README

.vscode/ltex.dictionary.en-US.txt

@@ -0,0 +1,7 @@
+Nevanlinna
+holomorphic
+integrability
+codiscrete
+meromorphy
+prover
+mathlib

.vscode/ltex.hiddenFalsePositives.en-US.txt

@@ -0,0 +1 @@
+{"rule":"MORFOLOGIK_RULE_EN_US","sentence":"^\\QHarmonic functions in the complex plane\nLaplace operator and associated API\nDefinition and elementary properties of harmonic functions\nMean value properties of harmonic functions\nReal and imaginary parts of holomorphic functions as examples of harmonic functions\nHolomorphic functions in the complex plane\nExistence of primitives [duplication of work already under review at mathlib]\nExistence of holomorphic functions with given real part\nMeromorphic Functions in the complex plane\nAPI for continuous extension of meromorphic functions, normal form of meromorphic functions up to changes along a discrete set\nBehavior of pole/zero orders under standard operations\nZero/pole divisors attached to meromorphic functions and associated API\nExtraction of zeros and poles\nIntegrals and integrability of special functions\nInterval integrals and integrability of the logarithm and its combinations with trigonometric functions; circle integrability of log ‖z-a‖\nCircle integrability of log ‖meromorphic‖\nBasic functions of Value Distribution Theory\nThe positive part of the logarithm, API, standard inequalities and estimates\nLogarithmic counting functions of divisors\nNevanlinna heights of entire meromorphic functions\nProximity functions for entire meromorphic functions\nJensen's formula\nNevanlinna's First Main Theorem\\E$"}

Nevanlinna.lean

@@ -1 +1,28 @@
-import Nevanlinna.cauchyRiemann
+import Nevanlinna.analyticAt
+import Nevanlinna.cauchyRiemann
+import Nevanlinna.codiscreteWithin
+import Nevanlinna.divisor
+import Nevanlinna.firstMain
+import Nevanlinna.harmonicAt
+import Nevanlinna.harmonicAt_examples
+import Nevanlinna.harmonicAt_meanValue
+import Nevanlinna.holomorphicAt
+import Nevanlinna.holomorphic_examples
+import Nevanlinna.holomorphic_primitive
+import Nevanlinna.intervalIntegrability
+import Nevanlinna.laplace
+import Nevanlinna.logpos
+import Nevanlinna.mathlibAddOn
+import Nevanlinna.meromorphicAt
+import Nevanlinna.meromorphicOn
+import Nevanlinna.meromorphicOn_divisor
+import Nevanlinna.meromorphicOn_integrability
+import Nevanlinna.partialDeriv
+import Nevanlinna.periodic_integrability
+import Nevanlinna.specialFunctions_CircleIntegral_affine
+import Nevanlinna.specialFunctions_Integral_log_sin
+import Nevanlinna.stronglyMeromorphicAt
+import Nevanlinna.stronglyMeromorphicOn
+import Nevanlinna.stronglyMeromorphicOn_eliminate
+import Nevanlinna.stronglyMeromorphicOn_ratlPolynomial
+import Nevanlinna.stronglyMeromorphic_JensenFormula

Nevanlinna/analyticAt.lean

@@ -2,6 +2,8 @@ import Mathlib.Analysis.Analytic.IsolatedZeros
 import Mathlib.Analysis.Complex.Basic
 import Mathlib.Analysis.Analytic.Linear
 
+open Topology
+
 
 theorem AnalyticAt.order_neq_top_iff
   {f : ℂ → ℂ}
@@ -116,10 +118,6 @@ theorem AnalyticAt.supp_order_toNat
   intro h₁f
   simp [hf.order_eq_zero_iff.2 h₁f]
 
-/-
-theorem ContinuousLinearEquiv.analyticAt
-  (ℓ : ℂ ≃L[ℂ] ℂ) (z₀ : ℂ) : AnalyticAt ℂ (⇑ℓ) z₀ := ℓ.toContinuousLinearMap.analyticAt z₀
--/
 
 theorem eventually_nhds_comp_composition
   {f₁ f₂ ℓ : ℂ → ℂ}
@@ -236,3 +234,111 @@ theorem AnalyticAt.order_comp_CLE
     rw [this]
 
     simp
+
+
+theorem AnalyticAt.localIdentity
+  {f g : ℂ → ℂ}
+  {z₀ : ℂ}
+  (hf : AnalyticAt ℂ f z₀)
+  (hg : AnalyticAt ℂ g z₀) :
+  f =ᶠ[𝓝[≠] z₀] g → f =ᶠ[𝓝 z₀] g := by
+  intro h
+  let Δ := f - g
+  have : AnalyticAt ℂ Δ z₀ := AnalyticAt.sub hf hg
+  have t₁ : Δ =ᶠ[𝓝[≠] z₀] 0 := by
+    exact Filter.eventuallyEq_iff_sub.mp h
+
+  have : Δ =ᶠ[𝓝 z₀] 0 := by
+    rcases (AnalyticAt.eventually_eq_zero_or_eventually_ne_zero this) with h | h
+    · exact h
+    · have := Filter.EventuallyEq.eventually t₁
+      let A := Filter.eventually_and.2 ⟨this, h⟩
+      let _ := Filter.Eventually.exists A
+      tauto
+  exact Filter.eventuallyEq_iff_sub.mpr this
+
+
+theorem AnalyticAt.mul₁
+  {f g : ℂ → ℂ}
+  {z : ℂ}
+  (hf : AnalyticAt ℂ f z)
+  (hg : AnalyticAt ℂ g z) :
+  AnalyticAt ℂ (f * g) z := by
+  rw [(by rfl : f * g = (fun x ↦ f x * g x))]
+  exact mul hf hg
+
+
+theorem analyticAt_finprod
+  {α : Type}
+  {f : α → ℂ → ℂ}
+  {z : ℂ}
+  (hf : ∀ a, AnalyticAt ℂ (f a) z) :
+  AnalyticAt ℂ (∏ᶠ a, f a) z := by
+  by_cases h₁f : (Function.mulSupport f).Finite
+  · rw [finprod_eq_prod f h₁f]
+    rw [Finset.prod_fn h₁f.toFinset f]
+    exact Finset.analyticAt_prod h₁f.toFinset (fun a _ ↦ hf a)
+  · rw [finprod_of_infinite_mulSupport h₁f]
+    exact analyticAt_const
+
+
+lemma AnalyticAt.zpow_nonneg
+  {f : ℂ → ℂ}
+  {z₀ : ℂ}
+  {n : ℤ}
+  (hf : AnalyticAt ℂ f z₀)
+  (hn : 0 ≤ n) :
+  AnalyticAt ℂ (fun x ↦ (f x) ^ n) z₀ := by
+  simp_rw [(Eq.symm (Int.toNat_of_nonneg hn) : n = OfNat.ofNat n.toNat), zpow_ofNat]
+  apply AnalyticAt.pow hf
+
+
+theorem AnalyticAt.zpow
+  {f : ℂ → ℂ}
+  {z₀ : ℂ}
+  {n : ℤ}
+  (h₁f : AnalyticAt ℂ f z₀)
+  (h₂f : f z₀ ≠ 0) :
+  AnalyticAt ℂ (fun x ↦ (f x) ^ n) z₀ := by
+  by_cases hn : 0 ≤ n
+  · exact zpow_nonneg h₁f hn
+  · rw [(Int.eq_neg_comm.mp rfl : n = - (- n))]
+    conv =>
+      arg 2
+      intro x
+      rw [zpow_neg]
+    exact AnalyticAt.inv (zpow_nonneg h₁f (by linarith)) (zpow_ne_zero (-n) h₂f)
+
+
+/- A function is analytic at a point iff it is analytic after multiplication
+   with a non-vanishing analytic function
+-/
+theorem analyticAt_of_mul_analytic
+  {f g : ℂ → ℂ}
+  {z₀ : ℂ}
+  (h₁g : AnalyticAt ℂ g z₀)
+  (h₂g : g z₀ ≠ 0) :
+  AnalyticAt ℂ f z₀ ↔ AnalyticAt ℂ (f * g) z₀ := by
+  constructor
+  · exact fun a => AnalyticAt.mul₁ a h₁g
+  · intro hprod
+
+    let g' := fun z ↦ (g z)⁻¹
+    have h₁g' := h₁g.inv h₂g
+    have h₂g' : g' z₀ ≠ 0 := by
+      exact inv_ne_zero h₂g
+
+    have : f =ᶠ[𝓝 z₀] f * g * fun x => (g x)⁻¹ := by
+      unfold Filter.EventuallyEq
+      apply Filter.eventually_iff_exists_mem.mpr
+      use g⁻¹' {0}ᶜ
+      constructor
+      · apply ContinuousAt.preimage_mem_nhds
+        exact AnalyticAt.continuousAt h₁g
+        exact compl_singleton_mem_nhds_iff.mpr h₂g
+      · intro y hy
+        simp at hy
+        simp [hy]
+    rw [analyticAt_congr this]
+    apply hprod.mul
+    exact h₁g'

Nevanlinna/cauchyRiemann.lean

@@ -31,7 +31,7 @@ theorem CauchyRiemann₃ : (DifferentiableAt ℂ f z)
   have ContinuousLinearMap.comp_lineDeriv : ∀ w : ℂ, ∀ l : ℂ →L[ℝ] ℝ, lineDeriv ℝ (l ∘ f) z w = l ((fderiv ℝ f z) w) := by
     intro w l
     rw [DifferentiableAt.lineDeriv_eq_fderiv]
-    rw [fderiv.comp]
+    rw [fderiv_comp]
     simp
     fun_prop
     exact h.restrictScalars ℝ

Nevanlinna/codiscreteWithin.lean

@@ -0,0 +1,11 @@
+import Mathlib.Topology.DiscreteSubset
+
+theorem codiscreteWithin_congr
+  {X : Type u_1} [TopologicalSpace X]
+  {S T U : Set X}
+  (hST : S ∩ U = T ∩ U) :
+  S ∈ Filter.codiscreteWithin U ↔ T ∈ Filter.codiscreteWithin U := by
+  repeat rw [mem_codiscreteWithin]
+  rw [← Set.diff_inter_self_eq_diff (t := S)]
+  rw [← Set.diff_inter_self_eq_diff (t := T)]
+  rw [hST]

Nevanlinna/divisor.lean

@@ -2,6 +2,7 @@ import Mathlib.Analysis.SpecialFunctions.Integrals
 import Mathlib.Analysis.SpecialFunctions.Log.NegMulLog
 import Mathlib.Analysis.Convex.SpecificFunctions.Deriv
 import Nevanlinna.analyticAt
+import Nevanlinna.mathlibAddOn
 
 open Interval Topology
 open Real Filter MeasureTheory intervalIntegral
@@ -20,3 +21,87 @@ instance
   coe := Divisor.toFun
 
 attribute [coe] Divisor.toFun
+
+
+
+theorem Divisor.discreteSupport
+  {U : Set ℂ}
+  (hU : IsClosed U)
+  (D : Divisor U) :
+  DiscreteTopology D.toFun.support := by
+  apply discreteTopology_subtype_iff.mpr
+  intro x hx
+  apply inf_principal_eq_bot.mpr
+  by_cases h₁x : x ∈ U
+  · let A := D.locallyFiniteInU x h₁x
+    refine mem_nhdsWithin.mpr ?_
+    rw [eventuallyEq_nhdsWithin_iff] at A
+    obtain ⟨U, h₁U, h₂U, h₃U⟩ := eventually_nhds_iff.1 A
+    use U
+    constructor
+    · exact h₂U
+    · constructor
+      · exact h₃U
+      · intro y hy
+        let C := h₁U y hy.1 hy.2
+        tauto
+  · refine mem_nhdsWithin.mpr ?_
+    use Uᶜ
+    constructor
+    · simpa
+    · constructor
+      · tauto
+      · intro y _
+        let A := D.supportInU
+        simp at A
+        simp
+        exact False.elim (h₁x (A x hx))
+
+
+theorem Divisor.closedSupport
+  {U : Set ℂ}
+  (hU : IsClosed U)
+  (D : Divisor U) :
+  IsClosed D.toFun.support := by
+
+  rw [← isOpen_compl_iff]
+  rw [isOpen_iff_eventually]
+  intro x hx
+  by_cases h₁x : x ∈ U
+  · have A := D.locallyFiniteInU x h₁x
+    simp [A]
+    simp at hx
+    let B := Mnhds A hx
+    simpa
+  · rw [eventually_iff_exists_mem]
+    use Uᶜ
+    constructor
+    · exact IsClosed.compl_mem_nhds hU h₁x
+    · intro y hy
+      simp
+      exact Function.nmem_support.mp fun a => hy (D.supportInU a)
+
+
+theorem Divisor.finiteSupport
+  {U : Set ℂ}
+  (hU : IsCompact U)
+  (D : Divisor U) :
+  Set.Finite D.toFun.support := by
+  apply IsCompact.finite
+  · apply IsCompact.of_isClosed_subset hU (D.closedSupport hU.isClosed)
+    exact D.supportInU
+  · exact D.discreteSupport hU.isClosed
+
+
+theorem Divisor.codiscreteWithin
+  {U : Set ℂ}
+  (D : Divisor U) :
+  D.toFun.supportᶜ ∈ Filter.codiscreteWithin U := by
+
+  simp_rw [mem_codiscreteWithin, disjoint_principal_right]
+  intro x hx
+  obtain ⟨s, hs⟩ := Filter.eventuallyEq_iff_exists_mem.1 (D.locallyFiniteInU x hx)
+  apply Filter.mem_of_superset hs.1
+  intro y hy
+  simp [hy]
+  tauto

Nevanlinna/firstMain.lean

@@ -1,21 +1,435 @@
-import Mathlib.Analysis.Analytic.Meromorphic
-import Nevanlinna.holomorphic_JensenFormula
+import Mathlib.MeasureTheory.Integral.CircleIntegral
+import Nevanlinna.divisor
+import Nevanlinna.meromorphicOn_divisor
+import Nevanlinna.meromorphicOn_integrability
+import Nevanlinna.stronglyMeromorphicOn
+import Nevanlinna.stronglyMeromorphic_JensenFormula
 
 open Real
 
-variable (f : ℂ → ℂ)
-variable {h₁f : MeromorphicOn f ⊤}
-variable {h₂f : f 0 ≠ 0}
+
+-- Lang p. 164
+
+theorem MeromorphicOn.restrict
+  {f : ℂ → ℂ}
+  (h₁f : MeromorphicOn f ⊤)
+  (r : ℝ) :
+  MeromorphicOn f (Metric.closedBall 0 r) := by
+  exact fun x a => h₁f x trivial
+
+theorem MeromorphicOn.restrict_inv
+  {f : ℂ → ℂ}
+  (h₁f : MeromorphicOn f ⊤)
+  (r : ℝ) :
+  h₁f.inv.restrict r = (h₁f.restrict r).inv := by
+  funext x
+  simp
 
 
+noncomputable def MeromorphicOn.N_zero
+  {f : ℂ → ℂ}
+  (hf : MeromorphicOn f ⊤) :
+  ℝ → ℝ :=
+  fun r ↦ ∑ᶠ z, (max 0 ((hf.restrict |r|).divisor z)) * log (r * ‖z‖⁻¹)
 
-noncomputable def Nevanlinna.n : ℝ → ℤ := by
-  intro r
-  have : MeromorphicAt f z := by
-    exact h₁f (sorryAx ℂ true) trivial
-  exact ∑ᶠ z ∈ Metric.ball (0 : ℂ) r, (h₁f z trivial).order
+noncomputable def MeromorphicOn.N_infty
+  {f : ℂ → ℂ}
+  (hf : MeromorphicOn f ⊤) :
+  ℝ → ℝ :=
+  fun r ↦ ∑ᶠ z, (max 0 (-((hf.restrict |r|).divisor z))) * log (r * ‖z‖⁻¹)
 
-noncomputable def integratedCounting : ℝ → ℝ := by
-  intro r
-  -- Issue here: for s on the boundary of the ball, zero comes out.
-  exact ∑ᶠ s, (h₁f.order s).toNat * log (r * ‖s.1‖⁻¹)
+
+theorem Nevanlinna_counting₁₁
+  {f : ℂ → ℂ}
+  (hf : MeromorphicOn f ⊤)
+  (a : ℂ) :
+  (hf.add (MeromorphicOn.const a)).N_infty = hf.N_infty := by
+
+  funext r
+  unfold MeromorphicOn.N_infty
+  let A := (hf.restrict |r|).divisor.finiteSupport (isCompact_closedBall 0 |r|)
+  repeat
+    rw [finsum_eq_sum_of_support_subset (s := A.toFinset)]
+  apply Finset.sum_congr rfl
+  intro x hx; simp at hx
+  congr 2
+
+  by_cases h : 0 ≤ (hf.restrict |r|).divisor x
+  · simp [h]
+    let A := (hf.restrict |r|).divisor_add_const₁ a h
+    exact A
+
+  · simp at h
+    have h' : 0 ≤ -((hf.restrict |r|).divisor x) := by
+      apply Int.le_neg_of_le_neg
+      simp
+      exact Int.le_of_lt h
+    simp [h']
+    clear h'
+
+    have A := (hf.restrict |r|).divisor_add_const₂ a h
+    have A' : 0 ≤ -((MeromorphicOn.add (MeromorphicOn.restrict hf |r|) (MeromorphicOn.const a)).divisor x) := by
+      apply Int.le_neg_of_le_neg
+      simp
+      exact Int.le_of_lt A
+    simp [A']
+    clear A A'
+
+    exact (hf.restrict |r|).divisor_add_const₃ a h
+  --
+  intro x
+  contrapose
+  simp
+  intro hx
+  rw [hx]
+  tauto
+  --
+  intro x
+  contrapose
+  simp
+  intro hx
+  have : 0 ≤ (hf.restrict |r|).divisor x := by
+    rw [hx]
+  have G := (hf.restrict |r|).divisor_add_const₁ a this
+  clear this
+  simp [G]
+
+theorem Nevanlinna_counting'₁₁
+  {f : ℂ → ℂ}
+  (hf : MeromorphicOn f ⊤)
+  (a : ℂ) :
+  (hf.sub (MeromorphicOn.const a)).N_infty = hf.N_infty := by
+  have : (f - fun x => a) = (f + fun x => -a) := by
+    funext x
+    simp; ring
+  have : (hf.sub (MeromorphicOn.const a)).N_infty = (hf.add (MeromorphicOn.const (-a))).N_infty := by
+    simp
+  rw [this]
+  exact Nevanlinna_counting₁₁ hf (-a)
+
+
+theorem Nevanlinna_counting₀
+  {f : ℂ → ℂ}
+  (hf : MeromorphicOn f ⊤) :
+  hf.inv.N_infty = hf.N_zero := by
+
+  funext r
+  unfold MeromorphicOn.N_zero MeromorphicOn.N_infty
+  let A := (hf.restrict |r|).divisor.finiteSupport (isCompact_closedBall 0 |r|)
+  repeat
+    rw [finsum_eq_sum_of_support_subset (s := A.toFinset)]
+  apply Finset.sum_congr rfl
+  intro x hx
+  congr
+  let B := hf.restrict_inv |r|
+  rw [MeromorphicOn.divisor_inv]
+  simp
+  --
+  exact fun x a => hf x trivial
+  --
+  intro x
+  contrapose
+  simp
+  intro hx
+  rw [hx]
+  tauto
+  --
+  intro x
+  contrapose
+  simp
+  intro hx h₁x
+
+  rw [MeromorphicOn.divisor_inv (hf.restrict |r|)] at h₁x
+  simp at h₁x
+  rw [hx] at h₁x
+  tauto
+
+
+theorem Nevanlinna_counting
+  {f : ℂ → ℂ}
+  (hf : MeromorphicOn f ⊤) :
+  hf.N_zero - hf.N_infty = fun r ↦ ∑ᶠ z, ((hf.restrict |r|).divisor z) * log (r * ‖z‖⁻¹) := by
+
+  funext r
+  simp only [Pi.sub_apply]
+  unfold  MeromorphicOn.N_zero MeromorphicOn.N_infty
+
+  let A := (hf.restrict |r|).divisor.finiteSupport (isCompact_closedBall 0 |r|)
+  repeat
+    rw [finsum_eq_sum_of_support_subset (s := A.toFinset)]
+  rw [← Finset.sum_sub_distrib]
+  simp_rw [← sub_mul]
+  congr
+  funext x
+  congr
+  by_cases h : 0 ≤ (hf.restrict |r|).divisor x
+  · simp [h]
+  · have h' : 0 ≤ -((hf.restrict |r|).divisor x) := by
+      simp at h
+      apply Int.le_neg_of_le_neg
+      simp
+      exact Int.le_of_lt h
+    simp at h
+    simp [h']
+    linarith
+  --
+  repeat
+    intro x
+    contrapose
+    simp
+    intro hx
+    rw [hx]
+    tauto
+
+
+--
+
+noncomputable def MeromorphicOn.m_infty
+  {f : ℂ → ℂ}
+  (_ : MeromorphicOn f ⊤) :
+  ℝ → ℝ :=
+  fun r ↦ (2 * π)⁻¹ * ∫ x in (0)..(2 * π), logpos ‖f (circleMap 0 r x)‖
+
+
+theorem Nevanlinna_proximity
+  {f : ℂ → ℂ}
+  {r : ℝ}
+  (h₁f : MeromorphicOn f ⊤) :
+  (2 * π)⁻¹ * ∫ x in (0)..(2 * π), log ‖f (circleMap 0 r x)‖ = (h₁f.m_infty r) - (h₁f.inv.m_infty r) := by
+
+  unfold MeromorphicOn.m_infty
+  rw [← mul_sub]; congr
+  rw [← intervalIntegral.integral_sub]; congr
+  funext x
+  simp_rw [loglogpos]; congr
+  exact Eq.symm (IsAbsoluteValue.abv_inv Norm.norm (f (circleMap 0 r x)))
+  --
+  apply MeromorphicOn.integrable_logpos_abs_f
+  intro z hx
+  exact h₁f z trivial
+  --
+  apply MeromorphicOn.integrable_logpos_abs_f
+  exact MeromorphicOn.inv_iff.mpr fun x a => h₁f x trivial
+
+
+noncomputable def MeromorphicOn.T_infty
+  {f : ℂ → ℂ}
+  (hf : MeromorphicOn f ⊤) :
+  ℝ → ℝ :=
+  hf.m_infty + hf.N_infty
+
+
+theorem Nevanlinna_firstMain₁
+  {f : ℂ → ℂ}
+  (h₁f : MeromorphicOn f ⊤)
+  (h₂f : StronglyMeromorphicAt f 0)
+  (h₃f : f 0 ≠ 0) :
+  (fun _ ↦ log ‖f 0‖) + h₁f.inv.T_infty = h₁f.T_infty := by
+
+  rw [add_eq_of_eq_sub]
+  unfold MeromorphicOn.T_infty
+
+  have {A B C D : ℝ → ℝ} : A + B - (C + D) = A - C - (D - B) := by
+    ring
+  rw [this]
+  clear this
+
+  rw [Nevanlinna_counting₀ h₁f]
+  rw [Nevanlinna_counting h₁f]
+  funext r
+  simp
+  rw [← Nevanlinna_proximity h₁f]
+
+  by_cases h₁r : r = 0
+  rw [h₁r]
+  simp
+  have : π⁻¹ * 2⁻¹ * (2 * π * log (Complex.abs (f 0))) = (π⁻¹ * (2⁻¹ * 2) * π) * log (Complex.abs (f 0)) := by
+    ring
+  rw [this]
+  clear this
+  simp [pi_ne_zero]
+
+  by_cases hr : 0 < r
+  let A := jensen hr f (h₁f.restrict r) h₂f h₃f
+  simp at A
+  rw [A]
+  clear A
+  simp
+  have {A B : ℝ} : -A + B = B - A := by ring
+  rw [this]
+  have : |r| = r := by
+    rw [← abs_of_pos hr]
+    simp
+  rw [this]
+
+  -- case 0 < -r
+  have h₂r : 0 < -r := by
+    simp [h₁r, hr]
+    by_contra hCon
+    -- Assume ¬(r < 0), which means r >= 0
+    push_neg at hCon
+    -- Now h is r ≥ 0, so we split into cases
+    rcases lt_or_eq_of_le hCon with h|h
+    · tauto
+    · tauto
+  let A := jensen h₂r f (h₁f.restrict (-r)) h₂f h₃f
+  simp at A
+  rw [A]
+  clear A
+  simp
+  have {A B : ℝ} : -A + B = B - A := by ring
+  rw [this]
+
+  congr 1
+  congr 1
+  let A := integrabl_congr_negRadius (f := (fun z ↦ log (Complex.abs (f z)))) (r := r)
+  rw [A]
+  have : |r| = -r := by
+    rw [← abs_of_pos h₂r]
+    simp
+  rw [this]
+
+
+theorem Nevanlinna_firstMain₂
+  {f : ℂ → ℂ}
+  {a : ℂ}
+  {r : ℝ}
+  (h₁f : MeromorphicOn f ⊤) :
+  |(h₁f.T_infty r) - ((h₁f.sub (MeromorphicOn.const a)).T_infty r)| ≤ logpos ‖a‖ + log 2 := by
+
+  -- See Lang, p. 168
+
+  have : (h₁f.T_infty r) - ((h₁f.sub (MeromorphicOn.const a)).T_infty r) = (h₁f.m_infty r) - ((h₁f.sub (MeromorphicOn.const a)).m_infty r) := by
+    unfold MeromorphicOn.T_infty
+    rw [Nevanlinna_counting'₁₁ h₁f a]
+    simp
+  rw [this]
+  clear this
+
+  unfold MeromorphicOn.m_infty
+  rw [←mul_sub]
+  rw [←intervalIntegral.integral_sub]
+
+  let g := f - (fun _ ↦ a)
+
+  have t₀₀ (x : ℝ) : log⁺ ‖f (circleMap 0 r x)‖ ≤ log⁺ ‖g (circleMap 0 r x)‖ + log⁺ ‖a‖ + log 2 := by
+    unfold g
+    simp only [Pi.sub_apply]
+
+    calc log⁺ ‖f (circleMap 0 r x)‖
+    _ = log⁺ ‖g (circleMap 0 r x) + a‖ := by
+      unfold g
+      simp
+    _ ≤ log⁺ (‖g (circleMap 0 r x)‖ + ‖a‖) := by
+      apply monoOn_logpos
+      refine Set.mem_Ici.mpr ?_
+      apply norm_nonneg
+      refine Set.mem_Ici.mpr ?_
+      apply add_nonneg
+      apply norm_nonneg
+      apply norm_nonneg
+      --
+      apply norm_add_le
+    _ ≤ log⁺ ‖g (circleMap 0 r x)‖ + log⁺ ‖a‖ + log 2 := by
+      apply logpos_add_le_add_logpos_add_log2
+
+  have t₁₀ (x : ℝ) : log⁺ ‖f (circleMap 0 r x)‖ - log⁺ ‖g (circleMap 0 r x)‖ ≤ log⁺ ‖a‖ + log 2 := by
+    rw [sub_le_iff_le_add]
+    nth_rw 1 [add_comm]
+    rw [←add_assoc]
+    apply t₀₀ x
+  clear t₀₀
+
+  have t₀₁ (x : ℝ) : log⁺ ‖g (circleMap 0 r x)‖ ≤ log⁺ ‖f (circleMap 0 r x)‖ + log⁺ ‖a‖ + log 2 := by
+    unfold g
+    simp only [Pi.sub_apply]
+
+    calc log⁺ ‖g (circleMap 0 r x)‖
+    _ = log⁺ ‖f (circleMap 0 r x) - a‖ := by
+      unfold g
+      simp
+    _ ≤ log⁺ (‖f (circleMap 0 r x)‖ + ‖a‖) := by
+      apply monoOn_logpos
+      refine Set.mem_Ici.mpr ?_
+      apply norm_nonneg
+      refine Set.mem_Ici.mpr ?_
+      apply add_nonneg
+      apply norm_nonneg
+      apply norm_nonneg
+      --
+      apply norm_sub_le
+    _ ≤ log⁺ ‖f (circleMap 0 r x)‖ + log⁺ ‖a‖ + log 2 := by
+      apply logpos_add_le_add_logpos_add_log2
+
+  have t₁₁ (x : ℝ) : log⁺ ‖g (circleMap 0 r x)‖ - log⁺ ‖f (circleMap 0 r x)‖ ≤ log⁺ ‖a‖ + log 2 := by
+    rw [sub_le_iff_le_add]
+    nth_rw 1 [add_comm]
+    rw [←add_assoc]
+    apply t₀₁ x
+  clear t₀₁
+
+  have t₂ {x : ℝ} : ‖log⁺ ‖f (circleMap 0 r x)‖ - log⁺ ‖g (circleMap 0 r x)‖‖ ≤ log⁺ ‖a‖ + log 2 := by
+    by_cases h : 0 ≤ log⁺ ‖f (circleMap 0 r x)‖ - log⁺ ‖g (circleMap 0 r x)‖
+    · rw [norm_of_nonneg h]
+      exact t₁₀ x
+    · rw [norm_of_nonpos (by linarith)]
+      rw [neg_sub]
+      exact t₁₁ x
+  clear t₁₀ t₁₁
+
+  have s₀ : ‖∫ (x : ℝ) in (0)..(2 * π), log⁺ ‖f (circleMap 0 r x)‖ - log⁺ ‖g (circleMap 0 r x)‖‖ ≤ (log⁺ ‖a‖ + log 2) * |2 * π - 0| := by
+    apply intervalIntegral.norm_integral_le_of_norm_le_const
+    intro x hx
+    exact t₂
+  clear t₂
+  simp only [norm_eq_abs, sub_zero] at s₀
+  rw [abs_mul]
+
+  have s₁ : |(2 * π)⁻¹| * |∫ (x : ℝ) in (0)..(2 * π), log⁺ ‖f (circleMap 0 r x)‖ - log⁺ ‖g (circleMap 0 r x)‖| ≤ |(2 * π)⁻¹| * ((log⁺ ‖a‖ + log 2) * |2 * π|) := by
+    apply mul_le_mul_of_nonneg_left
+    exact s₀
+    apply abs_nonneg
+  have : |(2 * π)⁻¹| * ((log⁺ ‖a‖ + log 2) * |2 * π|) = log⁺ ‖a‖ + log 2 := by
+    rw [mul_comm, mul_assoc]
+    have : |2 * π| * |(2 * π)⁻¹| = 1 := by
+      rw [abs_mul, abs_inv, abs_mul]
+      rw [abs_of_pos pi_pos]
+      simp [pi_ne_zero]
+      ring_nf
+      simp [pi_ne_zero]
+    rw [this]
+    simp
+  rw [this] at s₁
+  assumption
+
+  --
+  apply MeromorphicOn.integrable_logpos_abs_f
+  exact fun x a => h₁f x trivial
+  --
+  apply MeromorphicOn.integrable_logpos_abs_f
+  apply MeromorphicOn.sub
+  exact fun x a => h₁f x trivial
+  apply MeromorphicOn.const a
+
+
+open Asymptotics
+
+
+theorem Nevanlinna_firstMain'₂
+  {f : ℂ → ℂ}
+  {a : ℂ}
+  (h₁f : MeromorphicOn f ⊤) :
+  |(h₁f.T_infty) - ((h₁f.sub (MeromorphicOn.const a)).T_infty)| =O[Filter.atTop] (1 : ℝ → ℝ) := by
+
+  rw [Asymptotics.isBigO_iff']
+  use logpos ‖a‖ + log 2
+  constructor
+  · apply add_pos_of_nonneg_of_pos
+    apply logpos_nonneg
+    apply log_pos one_lt_two
+  · rw [Filter.eventually_atTop]
+    use 0
+    intro b hb
+    simp only [Pi.abs_apply, Pi.sub_apply, norm_eq_abs, abs_abs, Pi.one_apply,
+      norm_one, mul_one]
+    apply Nevanlinna_firstMain₂

Nevanlinna/harmonicAt.lean

@@ -22,7 +22,7 @@ theorem HarmonicAt_iff
   HarmonicAt f x ↔ ∃ s : Set ℂ, IsOpen s ∧ x ∈ s ∧ (ContDiffOn ℝ 2 f s) ∧ (∀ z ∈ s, Δ f z = 0) := by
   constructor
   · intro hf
-    obtain ⟨s₁, h₁s₁, h₂s₁, h₃s₁⟩ := hf.1.contDiffOn' le_rfl
+    obtain ⟨s₁, h₁s₁, h₂s₁, h₃s₁⟩ := hf.1.contDiffOn' le_rfl (by trivial)
     simp at h₃s₁
     obtain ⟨t₂, h₁t₂, h₂t₂⟩ := (Filter.eventuallyEq_iff_exists_mem.1 hf.2)
     obtain ⟨s₂, h₁s₂, h₂s₂, h₃s₂⟩ := mem_nhds_iff.1 h₁t₂
@@ -261,7 +261,7 @@ theorem harmonicAt_comp_CLM_is_harmonicAt
     apply ContDiffAt.continuousLinearMap_comp
     exact h.1
   · -- Δ (⇑l ∘ f) =ᶠ[nhds z] 0
-    obtain ⟨r, h₁r, h₂r⟩ := h.1.contDiffOn le_rfl
+    obtain ⟨r, h₁r, h₂r⟩ := h.1.contDiffOn le_rfl (by trivial)
     obtain ⟨s, h₁s, h₂s, h₃s⟩ := mem_nhds_iff.1 h₁r
     obtain ⟨t, h₁t, h₂t⟩ := Filter.eventuallyEq_iff_exists_mem.1 h.2
     obtain ⟨u, h₁u, h₂u, h₃u⟩ := mem_nhds_iff.1 h₁t

Nevanlinna/holomorphic_JensenFormula.lean

@@ -1,449 +0,0 @@
-import Mathlib.Analysis.Complex.CauchyIntegral
-import Mathlib.Analysis.Analytic.IsolatedZeros
-import Nevanlinna.analyticOnNhd_zeroSet
-import Nevanlinna.harmonicAt_examples
-import Nevanlinna.harmonicAt_meanValue
-import Nevanlinna.specialFunctions_CircleIntegral_affine
-
-open Real
-
-
-
-theorem jensen_case_R_eq_one
-  (f : ℂ → ℂ)
-  (h₁f : AnalyticOnNhd ℂ f (Metric.closedBall 0 1))
-  (h₂f : f 0 ≠ 0) :
-  log ‖f 0‖ = -∑ᶠ s, (h₁f.order s).toNat * log (‖s.1‖⁻¹) + (2 * π)⁻¹ * ∫ (x : ℝ) in (0)..(2 * π), log ‖f (circleMap 0 1 x)‖ := by
-
-  have h₁U : IsPreconnected (Metric.closedBall (0 : ℂ) 1) :=
-    (convex_closedBall (0 : ℂ) 1).isPreconnected
-
-  have h₂U : IsCompact (Metric.closedBall (0 : ℂ) 1) :=
-    isCompact_closedBall 0 1
-
-  have h'₂f : ∃ u ∈ (Metric.closedBall (0 : ℂ) 1), f u ≠ 0 := by
-    use 0; simp; exact h₂f
-
-  obtain ⟨F, h₁F, h₂F, h₃F⟩ := AnalyticOnNhdCompact.eliminateZeros₂ h₁U h₂U h₁f h'₂f
-
-  have h'₁F : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, HolomorphicAt F z := by
-    intro z h₁z
-    apply AnalyticAt.holomorphicAt
-    exact h₁F z h₁z
-
-  let G := fun z ↦ log ‖F z‖ + ∑ s ∈ (finiteZeros h₁U h₂U h₁f h'₂f).toFinset, (h₁f.order s).toNat * log ‖z - s‖
-
-  have decompose_f : ∀ z ∈ Metric.closedBall (0 : ℂ) 1, f z ≠ 0 → log ‖f z‖ = G z := by
-    intro z h₁z h₂z
-
-    conv =>
-      left
-      arg 1
-      rw [h₃F]
-      rw [smul_eq_mul]
-      rw [norm_mul]
-      rw [norm_prod]
-      left
-      arg 2
-      intro b
-      rw [norm_pow]
-    simp only [Complex.norm_eq_abs, Finset.univ_eq_attach]
-    rw [Real.log_mul]
-    rw [Real.log_prod]
-    conv =>
-      left
-      left
-      arg 2
-      intro s
-      rw [Real.log_pow]
-    dsimp [G]
-    abel
-
-    -- ∀ x ∈ ⋯.toFinset, Complex.abs (z - ↑x) ^ (h'₁f.order x).toNat ≠ 0
-    have : ∀ x ∈ (finiteZeros h₁U h₂U h₁f h'₂f).toFinset, Complex.abs (z - ↑x) ^ (h₁f.order x).toNat ≠ 0 := by
-      intro s hs
-      simp at hs
-      simp
-      intro h₂s
-      rw [h₂s] at h₂z
-      tauto
-    exact this
-
-    -- ∏ x ∈ ⋯.toFinset, Complex.abs (z - ↑x) ^ (h'₁f.order x).toNat ≠ 0
-    have : ∀ x ∈ (finiteZeros h₁U h₂U h₁f h'₂f).toFinset, Complex.abs (z - ↑x) ^ (h₁f.order x).toNat ≠ 0 := by
-      intro s hs
-      simp at hs
-      simp
-      intro h₂s
-      rw [h₂s] at h₂z
-      tauto
-    rw [Finset.prod_ne_zero_iff]
-    exact this
-
-    -- Complex.abs (F z) ≠ 0
-    simp
-    exact h₂F z h₁z
-
-
-  have int_logAbs_f_eq_int_G : ∫ (x : ℝ) in (0)..2 * π, log ‖f (circleMap 0 1 x)‖ = ∫ (x : ℝ) in (0)..2 * π, G (circleMap 0 1 x) := by
-
-    rw [intervalIntegral.integral_congr_ae]
-    rw [MeasureTheory.ae_iff]
-    apply Set.Countable.measure_zero
-    simp
-
-    have t₀ : {a | a ∈ Ι 0 (2 * π) ∧ ¬log ‖f (circleMap 0 1 a)‖ = G (circleMap 0 1 a)}
-      ⊆ (circleMap 0 1)⁻¹' (Metric.closedBall 0 1 ∩ f⁻¹' {0}) := by
-      intro a ha
-      simp at ha
-      simp
-      by_contra C
-      have : (circleMap 0 1 a) ∈ Metric.closedBall 0 1 :=
-        circleMap_mem_closedBall 0 (zero_le_one' ℝ) a
-      exact ha.2 (decompose_f (circleMap 0 1 a) this C)
-
-    apply Set.Countable.mono t₀
-    apply Set.Countable.preimage_circleMap
-    apply Set.Finite.countable
-    let A := finiteZeros h₁U h₂U h₁f h'₂f
-
-    have : (Metric.closedBall 0 1 ∩ f ⁻¹' {0}) = (Metric.closedBall 0 1).restrict f ⁻¹' {0} := by
-      ext z
-      simp
-      tauto
-    rw [this]
-    exact Set.Finite.image Subtype.val A
-    exact Ne.symm (zero_ne_one' ℝ)
-
-
-  have decompose_int_G : ∫ (x : ℝ) in (0)..2 * π, G (circleMap 0 1 x)
-    = (∫ (x : ℝ) in (0)..2 * π, log (Complex.abs (F (circleMap 0 1 x))))
-        + ∑ x ∈ (finiteZeros h₁U h₂U h₁f h'₂f).toFinset, (h₁f.order x).toNat * ∫ (x_1 : ℝ) in (0)..2 * π, log (Complex.abs (circleMap 0 1 x_1 - ↑x)) := by
-    dsimp [G]
-    rw [intervalIntegral.integral_add]
-    rw [intervalIntegral.integral_finset_sum]
-    simp_rw [intervalIntegral.integral_const_mul]
-
-    --  ∀ i ∈ (finiteZeros h₁U h₂U h'₁f h'₂f).toFinset,
-    --  IntervalIntegrable (fun x => (h'₁f.order i).toNat *
-    --    log (Complex.abs (circleMap 0 1 x - ↑i))) MeasureTheory.volume 0 (2 * π)
-    intro i _
-    apply IntervalIntegrable.const_mul
-    --simp at this
-    by_cases h₂i : ‖i.1‖ = 1
-    -- case pos
-    exact int'₂ h₂i
-    -- case neg
-    apply Continuous.intervalIntegrable
-    apply continuous_iff_continuousAt.2
-    intro x
-    have : (fun x => log (Complex.abs (circleMap 0 1 x - ↑i))) = log ∘ Complex.abs ∘ (fun x ↦ circleMap 0 1 x - ↑i) :=
-      rfl
-    rw [this]
-    apply ContinuousAt.comp
-    apply Real.continuousAt_log
-    simp
-
-    by_contra ha'
-    conv at h₂i =>
-      arg 1
-      rw [← ha']
-      rw [Complex.norm_eq_abs]
-      rw [abs_circleMap_zero 1 x]
-      simp
-    tauto
-    apply ContinuousAt.comp
-    apply Complex.continuous_abs.continuousAt
-    fun_prop
-    -- IntervalIntegrable (fun x => log (Complex.abs (F (circleMap 0 1 x)))) MeasureTheory.volume 0 (2 * π)
-    apply Continuous.intervalIntegrable
-    apply continuous_iff_continuousAt.2
-    intro x
-    have : (fun x => log (Complex.abs (F (circleMap 0 1 x)))) = log ∘ Complex.abs ∘ F ∘ (fun x ↦ circleMap 0 1 x) :=
-      rfl
-    rw [this]
-    apply ContinuousAt.comp
-    apply Real.continuousAt_log
-    simp [h₂F]
-    -- ContinuousAt (⇑Complex.abs ∘ F ∘ fun x => circleMap 0 1 x) x
-    apply ContinuousAt.comp
-    apply Complex.continuous_abs.continuousAt
-    apply ContinuousAt.comp
-    apply DifferentiableAt.continuousAt (𝕜 := ℂ )
-    apply HolomorphicAt.differentiableAt
-    simp [h'₁F]
-    -- ContinuousAt (fun x => circleMap 0 1 x) x
-    apply Continuous.continuousAt
-    apply continuous_circleMap
-
-    have : (fun x => ∑ s ∈ (finiteZeros h₁U h₂U h₁f h'₂f).toFinset, (h₁f.order s).toNat * log (Complex.abs (circleMap 0 1 x - ↑s)))
-      = ∑ s ∈ (finiteZeros h₁U h₂U h₁f h'₂f).toFinset, (fun x => (h₁f.order s).toNat * log (Complex.abs (circleMap 0 1 x - ↑s))) := by
-      funext x
-      simp
-    rw [this]
-    apply IntervalIntegrable.sum
-    intro i _
-    apply IntervalIntegrable.const_mul
-    --have : i.1 ∈ Metric.closedBall (0 : ℂ) 1 := i.2
-    --simp at this
-    by_cases h₂i : ‖i.1‖ = 1
-    -- case pos
-    exact int'₂ h₂i
-    -- case neg
-    --have : i.1 ∈ Metric.ball (0 : ℂ) 1 := by sorry
-    apply Continuous.intervalIntegrable
-    apply continuous_iff_continuousAt.2
-    intro x
-    have : (fun x => log (Complex.abs (circleMap 0 1 x - ↑i))) = log ∘ Complex.abs ∘ (fun x ↦ circleMap 0 1 x - ↑i) :=
-      rfl
-    rw [this]
-    apply ContinuousAt.comp
-    apply Real.continuousAt_log
-    simp
-
-    by_contra ha'
-    conv at h₂i =>
-      arg 1
-      rw [← ha']
-      rw [Complex.norm_eq_abs]
-      rw [abs_circleMap_zero 1 x]
-      simp
-    tauto
-    apply ContinuousAt.comp
-    apply Complex.continuous_abs.continuousAt
-    fun_prop
-
-  have t₁ : (∫ (x : ℝ) in (0)..2 * Real.pi, log ‖F (circleMap 0 1 x)‖) = 2 * Real.pi * log ‖F 0‖ := by
-    let logAbsF := fun w ↦ Real.log ‖F w‖
-    have t₀ : ∀ z ∈ Metric.closedBall 0 1, HarmonicAt logAbsF z := by
-      intro z hz
-      apply logabs_of_holomorphicAt_is_harmonic
-      apply h'₁F z hz
-      exact h₂F z hz
-
-    apply harmonic_meanValue₁ 1 Real.zero_lt_one t₀
-
-  simp_rw [← Complex.norm_eq_abs] at decompose_int_G
-  rw [t₁] at decompose_int_G
-
-  conv at decompose_int_G =>
-    right
-    right
-    arg 2
-    intro x
-    right
-    rw [int₃ x.2]
-  simp at decompose_int_G
-
-  rw [int_logAbs_f_eq_int_G]
-  rw [decompose_int_G]
-  rw [h₃F]
-  simp
-  have {l : ℝ} : π⁻¹ * 2⁻¹ * (2 * π * l) = l := by
-    calc π⁻¹ * 2⁻¹ * (2 * π * l)
-    _ = π⁻¹ * (2⁻¹ * 2) * π * l := by ring
-    _ = π⁻¹ * π * l := by ring
-    _ = (π⁻¹ * π) * l := by ring
-    _ = 1 * l := by
-      rw [inv_mul_cancel₀]
-      exact pi_ne_zero
-    _ = l := by simp
-  rw [this]
-  rw [log_mul]
-  rw [log_prod]
-  simp
-
-  rw [finsum_eq_sum_of_support_subset _ (s := (finiteZeros h₁U h₂U h₁f h'₂f).toFinset)]
-  simp
-  simp
-  intro x ⟨h₁x, _⟩
-  simp
-
-  dsimp [AnalyticOnNhd.order] at h₁x
-  simp only [Function.mem_support, ne_eq, Nat.cast_eq_zero, not_or] at h₁x
-  exact AnalyticAt.supp_order_toNat (AnalyticOnNhd.order.proof_1 h₁f x) h₁x
-
-  --
-  intro x hx
-  simp at hx
-  simp
-  intro h₁x
-  nth_rw 1 [← h₁x] at h₂f
-  tauto
-
-  --
-  rw [Finset.prod_ne_zero_iff]
-  intro x hx
-  simp at hx
-  simp
-  intro h₁x
-  nth_rw 1 [← h₁x] at h₂f
-  tauto
-
-  --
-  simp
-  apply h₂F
-  simp
-
-
-lemma const_mul_circleMap_zero
-  {R θ : ℝ} :
-  circleMap 0 R θ = R * circleMap 0 1 θ := by
-  rw [circleMap_zero, circleMap_zero]
-  simp
-
-
-theorem jensen
-  {R : ℝ}
-  (hR : 0 < R)
-  (f : ℂ → ℂ)
-  (h₁f : AnalyticOnNhd ℂ f (Metric.closedBall 0 R))
-  (h₂f : f 0 ≠ 0) :
-  log ‖f 0‖ = -∑ᶠ s, (h₁f.order s).toNat * log (R * ‖s.1‖⁻¹) + (2 * π)⁻¹ * ∫ (x : ℝ) in (0)..(2 * π), log ‖f (circleMap 0 R x)‖ := by
-
-
-  let ℓ : ℂ ≃L[ℂ] ℂ :=
-  {
-    toFun := fun x ↦ R * x
-    map_add' := fun x y => DistribSMul.smul_add R x y
-    map_smul' := fun m x => mul_smul_comm m (↑R) x
-    invFun := fun x ↦ R⁻¹ * x
-    left_inv := by
-      intro x
-      simp
-      rw [← mul_assoc, mul_comm, inv_mul_cancel₀, mul_one]
-      simp
-      exact ne_of_gt hR
-    right_inv := by
-      intro x
-      simp
-      rw [← mul_assoc, mul_inv_cancel₀, one_mul]
-      simp
-      exact ne_of_gt hR
-    continuous_toFun := continuous_const_smul R
-    continuous_invFun := continuous_const_smul R⁻¹
-  }
-
-
-  let F := f ∘ ℓ
-
-  have h₁F : AnalyticOnNhd ℂ F (Metric.closedBall 0 1) := by
-    apply AnalyticOnNhd.comp (t := Metric.closedBall 0 R)
-    exact h₁f
-    intro x _
-    apply ℓ.toContinuousLinearMap.analyticAt x
-
-    intro x hx
-    have : ℓ x = R * x := by rfl
-    rw [this]
-    simp
-    simp at hx
-    rw [abs_of_pos hR]
-    calc R * Complex.abs x
-    _ ≤ R * 1 := by exact (mul_le_mul_iff_of_pos_left hR).mpr hx
-    _ = R := by simp
-
-  have h₂F : F 0 ≠ 0 := by
-    dsimp [F]
-    have : ℓ 0 = R * 0 := by rfl
-    rw [this]
-    simpa
-
-  let A := jensen_case_R_eq_one F h₁F h₂F
-
-  dsimp [F] at A
-  have {x : ℂ} : ℓ x = R * x := by rfl
-  repeat
-    simp_rw [this] at A
-  simp at A
-  simp
-  rw [A]
-  simp_rw [← const_mul_circleMap_zero]
-  simp
-
-  let e : (Metric.closedBall (0 : ℂ) 1) → (Metric.closedBall (0 : ℂ) R) := by
-    intro ⟨x, hx⟩
-    have hy : R • x ∈ Metric.closedBall (0 : ℂ) R := by
-      simp
-      simp at hx
-      have : R = |R| := by exact Eq.symm (abs_of_pos hR)
-      rw [← this]
-      norm_num
-      calc R * Complex.abs x
-      _ ≤ R * 1 := by exact (mul_le_mul_iff_of_pos_left hR).mpr hx
-      _ = R := by simp
-    exact ⟨R • x, hy⟩
-
-  let e' : (Metric.closedBall (0 : ℂ) R) → (Metric.closedBall (0 : ℂ) 1) := by
-    intro ⟨x, hx⟩
-    have hy : R⁻¹ • x ∈ Metric.closedBall (0 : ℂ) 1 := by
-      simp
-      simp at hx
-      have : R = |R| := by exact Eq.symm (abs_of_pos hR)
-      rw [← this]
-      norm_num
-      calc R⁻¹ * Complex.abs x
-      _ ≤ R⁻¹ * R := by
-        apply mul_le_mul_of_nonneg_left hx
-        apply inv_nonneg.mpr
-        exact abs_eq_self.mp (id (Eq.symm this))
-      _ = 1 := by
-        apply inv_mul_cancel₀
-        exact Ne.symm (ne_of_lt hR)
-    exact ⟨R⁻¹ • x, hy⟩
-
-  apply finsum_eq_of_bijective e
-
-
-  apply Function.bijective_iff_has_inverse.mpr
-  use e'
-  constructor
-  · apply Function.leftInverse_iff_comp.mpr
-    funext x
-    dsimp only [e, e',  id_eq, eq_mp_eq_cast, Function.comp_apply]
-    conv =>
-      left
-      arg 1
-      rw [← smul_assoc, smul_eq_mul]
-      rw [inv_mul_cancel₀ (Ne.symm (ne_of_lt hR))]
-      rw [one_smul]
-  · apply Function.rightInverse_iff_comp.mpr
-    funext x
-    dsimp only [e, e',  id_eq, eq_mp_eq_cast, Function.comp_apply]
-    conv =>
-      left
-      arg 1
-      rw [← smul_assoc, smul_eq_mul]
-      rw [mul_inv_cancel₀ (Ne.symm (ne_of_lt hR))]
-      rw [one_smul]
-
-  intro x
-  simp
-  by_cases hx : x = (0 : ℂ)
-  rw [hx]
-  simp
-
-  rw [log_mul, log_mul, log_inv, log_inv]
-  have : R = |R| := by exact Eq.symm (abs_of_pos hR)
-  rw [← this]
-  simp
-  left
-  congr 1
-
-  dsimp [AnalyticOnNhd.order]
-  rw [← AnalyticAt.order_comp_CLE ℓ]
-
-  --
-  simpa
-  --
-  have : R = |R| := by exact Eq.symm (abs_of_pos hR)
-  rw [← this]
-  apply inv_ne_zero
-  exact Ne.symm (ne_of_lt hR)
-  --
-  exact Ne.symm (ne_of_lt hR)
-  --
-  simp
-  constructor
-  · assumption
-  · exact Ne.symm (ne_of_lt hR)

Nevanlinna/holomorphic_examples.lean

@@ -204,7 +204,7 @@ theorem harmonic_is_realOfHolomorphic
 
       --DifferentiableAt ℝ (partialDeriv ℝ _ f)
       repeat
-        apply ContDiffAt.differentiableAt
+        apply ContDiffAt.differentiableAt (n := 1)
         apply partialDeriv_contDiffAt ℝ (hf x hx).1
         apply le_rfl
 
@@ -277,7 +277,7 @@ theorem harmonic_is_realOfHolomorphic
 
     intro x hx
     rw [fderivWithin_eq_fderiv, fderivWithin_eq_fderiv]
-    rw [fderiv.comp]
+    rw [fderiv_comp]
     simp
     apply ContinuousLinearMap.ext
     intro w

Nevanlinna/holomorphic_zero.lean

@@ -1,358 +0,0 @@
-import Init.Classical
-import Mathlib.Analysis.Analytic.Meromorphic
-import Mathlib.Topology.ContinuousOn
-import Mathlib.Analysis.Analytic.IsolatedZeros
-import Nevanlinna.holomorphic
-import Nevanlinna.analyticOnNhd_zeroSet
-
-
-noncomputable def zeroDivisor
-  (f : ℂ → ℂ) :
-  ℂ → ℕ := by
-  intro z
-  by_cases hf : AnalyticAt ℂ f z
-  · exact hf.order.toNat
-  · exact 0
-
-
-theorem analyticAtZeroDivisorSupport
-  {f : ℂ → ℂ}
-  {z : ℂ}
-  (h : z ∈ Function.support (zeroDivisor f)) :
-  AnalyticAt ℂ f z := by
-
-  by_contra h₁f
-  simp at h
-  dsimp [zeroDivisor] at h
-  simp [h₁f] at h
-
-
-theorem zeroDivisor_eq_ord_AtZeroDivisorSupport
-  {f : ℂ → ℂ}
-  {z : ℂ}
-  (h : z ∈ Function.support (zeroDivisor f)) :
-  zeroDivisor f z = (analyticAtZeroDivisorSupport h).order.toNat := by
-
-  unfold zeroDivisor
-  simp [analyticAtZeroDivisorSupport h]
-
-
-theorem zeroDivisor_eq_ord_AtZeroDivisorSupport'
-  {f : ℂ → ℂ}
-  {z : ℂ}
-  (h : z ∈ Function.support (zeroDivisor f)) :
-  zeroDivisor f z = (analyticAtZeroDivisorSupport h).order := by
-
-  unfold zeroDivisor
-  simp [analyticAtZeroDivisorSupport h]
-  sorry
-
-
-lemma toNatEqSelf_iff {n : ℕ∞} : n.toNat = n ↔ ∃ m : ℕ, m = n := by
-  constructor
-  · intro H₁
-    rw [← ENat.some_eq_coe, ← WithTop.ne_top_iff_exists]
-    by_contra H₂
-    rw [H₂] at H₁
-    simp at H₁
-  · intro H
-    obtain ⟨m, hm⟩ := H
-    rw [← hm]
-    simp
-
-
-lemma natural_if_toNatNeZero {n : ℕ∞} : n.toNat ≠ 0 → ∃ m : ℕ, m = n := by
-  rw [← ENat.some_eq_coe, ← WithTop.ne_top_iff_exists]
-  contrapose; simp; tauto
-
-
-theorem zeroDivisor_localDescription
-  {f : ℂ → ℂ}
-  {z₀ : ℂ}
-  (h : z₀ ∈ Function.support (zeroDivisor f)) :
-  ∃ (g : ℂ → ℂ), AnalyticAt ℂ g z₀ ∧ g z₀ ≠ 0 ∧ ∀ᶠ (z : ℂ) in nhds z₀, f z = (z - z₀) ^ (zeroDivisor f z₀) • g z := by
-
-  have A : zeroDivisor f ↑z₀ ≠ 0 := by exact h
-  let B := zeroDivisor_eq_ord_AtZeroDivisorSupport h
-  rw [B] at A
-  have C := natural_if_toNatNeZero A
-  obtain ⟨m, hm⟩ := C
-  have h₂m : m ≠ 0 := by
-    rw [← hm] at A
-    simp at A
-    assumption
-  rw [eq_comm] at hm
-  let E := AnalyticAt.order_eq_nat_iff (analyticAtZeroDivisorSupport h) m
-  let F := hm
-  rw [E] at F
-
-  have : m = zeroDivisor f z₀ := by
-    rw [B, hm]
-    simp
-  rwa [this] at F
-
-
-theorem zeroDivisor_zeroSet
-  {f : ℂ → ℂ}
-  {z₀ : ℂ}
-  (h : z₀ ∈ Function.support (zeroDivisor f)) :
-  f z₀ = 0 := by
-  obtain ⟨g, _, _, h₃⟩ := zeroDivisor_localDescription h
-  rw [Filter.Eventually.self_of_nhds h₃]
-  simp
-  left
-  exact h
-
-
-theorem zeroDivisor_support_iff
-  {f : ℂ → ℂ}
-  {z₀ : ℂ} :
-  z₀ ∈ Function.support (zeroDivisor f) ↔
-  f z₀ = 0 ∧
-  AnalyticAt ℂ f z₀ ∧
-  ∃ (g : ℂ → ℂ), AnalyticAt ℂ g z₀ ∧ g z₀ ≠ 0 ∧ ∀ᶠ (z : ℂ) in nhds z₀, f z = (z - z₀) ^ (zeroDivisor f z₀) • g z := by
-  constructor
-  · intro hz
-    constructor
-    · exact zeroDivisor_zeroSet hz
-    · constructor
-      · exact analyticAtZeroDivisorSupport hz
-      · exact zeroDivisor_localDescription hz
-  · intro ⟨h₁, h₂, h₃⟩
-    have : zeroDivisor f z₀ = (h₂.order).toNat := by
-      unfold zeroDivisor
-      simp [h₂]
-    simp [this]
-    simp [(h₂.order_eq_nat_iff (zeroDivisor f z₀)).2 h₃]
-    obtain ⟨g, h₁g, h₂g, h₃g⟩ := h₃
-    rw [Filter.Eventually.self_of_nhds h₃g] at h₁
-    simp [h₂g] at h₁
-    assumption
-
-
-theorem topOnPreconnected
-  {f : ℂ → ℂ}
-  {U : Set ℂ}
-  (hU : IsPreconnected U)
-  (h₁f : AnalyticOnNhd ℂ f U)
-  (h₂f : ∃ z ∈ U, f z ≠ 0) :
-  ∀ (hz : z ∈ U), (h₁f z hz).order ≠ ⊤ := by
-
-  by_contra H
-  push_neg at H
-  obtain ⟨z', hz'⟩ := H
-  rw [AnalyticAt.order_eq_top_iff] at hz'
-  rw [← AnalyticAt.frequently_zero_iff_eventually_zero (h₁f z z')] at hz'
-  have A := AnalyticOnNhd.eqOn_zero_of_preconnected_of_frequently_eq_zero h₁f hU z' hz'
-  tauto
-
-
-theorem supportZeroSet
-  {f : ℂ → ℂ}
-  {U : Set ℂ}
-  (hU : IsPreconnected U)
-  (h₁f : AnalyticOnNhd ℂ f U)
-  (h₂f : ∃ z ∈ U, f z ≠ 0) :
-  U ∩ Function.support (zeroDivisor f) = U ∩ f⁻¹' {0} := by
-
-  ext x
-  constructor
-  · intro hx
-    constructor
-    · exact hx.1
-    exact zeroDivisor_zeroSet hx.2
-  · simp
-    intro h₁x h₂x
-    constructor
-    · exact h₁x
-    · let A := zeroDivisor_support_iff (f := f) (z₀ := x)
-      simp at A
-      rw [A]
-      constructor
-      · exact h₂x
-      · constructor
-        · exact h₁f x h₁x
-        · have B := AnalyticAt.order_eq_nat_iff (h₁f x h₁x) (zeroDivisor f x)
-          simp at B
-          rw [← B]
-          dsimp [zeroDivisor]
-          simp [h₁f x h₁x]
-          refine Eq.symm (ENat.coe_toNat ?h.mpr.right.right.right.a)
-          exact topOnPreconnected hU h₁f h₂f h₁x
-
-/-
-theorem discreteZeros
-  {f : ℂ → ℂ} :
-  DiscreteTopology (Function.support (zeroDivisor f)) := by
-
-  simp_rw [← singletons_open_iff_discrete, Metric.isOpen_singleton_iff]
-  intro z
-
-  have A : zeroDivisor f ↑z ≠ 0 := by exact z.2
-  let B := zeroDivisor_eq_ord_AtZeroDivisorSupport z.2
-  rw [B] at A
-  have C := natural_if_toNatNeZero A
-  obtain ⟨m, hm⟩ := C
-  have h₂m : m ≠ 0 := by
-    rw [← hm] at A
-    simp at A
-    assumption
-  rw [eq_comm] at hm
-  let E := AnalyticAt.order_eq_nat_iff (analyticAtZeroDivisorSupport z.2) m
-  rw [E] at hm
-
-  obtain ⟨g, h₁g, h₂g, h₃g⟩ := hm
-
-  rw [Metric.eventually_nhds_iff_ball] at h₃g
-  have : ∃ ε > 0, ∀ y ∈ Metric.ball (↑z) ε, g y ≠ 0 := by
-    have h₄g : ContinuousAt g z := AnalyticAt.continuousAt h₁g
-    have : {0}ᶜ ∈ nhds (g z) := by
-      exact compl_singleton_mem_nhds_iff.mpr h₂g
-
-    let F := h₄g.preimage_mem_nhds this
-    rw [Metric.mem_nhds_iff] at F
-    obtain ⟨ε, h₁ε, h₂ε⟩ := F
-    use ε
-    constructor; exact h₁ε
-    intro y hy
-    let G := h₂ε hy
-    simp at G
-    exact G
-  obtain ⟨ε₁, h₁ε₁⟩ := this
-
-  obtain ⟨ε₂, h₁ε₂, h₂ε₂⟩ := h₃g
-  use min ε₁ ε₂
-  constructor
-  · have : 0 < min ε₁ ε₂ := by
-      rw [lt_min_iff]
-      exact And.imp_right (fun _ => h₁ε₂) h₁ε₁
-    exact this
-
-  intro y
-  intro h₁y
-
-  have h₂y : ↑y ∈ Metric.ball (↑z) ε₂ := by
-    simp
-    calc dist y z
-    _ < min ε₁ ε₂ := by assumption
-    _ ≤ ε₂ := by exact min_le_right ε₁ ε₂
-
-  have h₃y : ↑y ∈ Metric.ball (↑z) ε₁ := by
-    simp
-    calc dist y z
-    _ < min ε₁ ε₂ := by assumption
-    _ ≤ ε₁ := by exact min_le_left ε₁ ε₂
-
-  let F := h₂ε₂ y.1 h₂y
-  rw [zeroDivisor_zeroSet y.2] at F
-  simp at F
-
-  simp [h₂m] at F
-
-  have : g y.1 ≠ 0 := by
-    exact h₁ε₁.2 y h₃y
-  simp [this] at F
-  ext
-  rwa [sub_eq_zero] at F
--/
-
-theorem zeroDivisor_finiteOnCompact
-  {f : ℂ → ℂ}
-  {U : Set ℂ}
-  (hU : IsPreconnected U)
-  (h₁f : AnalyticOnNhd ℂ f U)
-  (h₂f : ∃ z ∈ U, f z ≠ 0) -- not needed!
-  (h₂U : IsCompact U) :
-  Set.Finite (U ∩ Function.support (zeroDivisor f)) := by
-
-  have hinter : IsCompact (U ∩ Function.support (zeroDivisor f)) := by
-    apply IsCompact.of_isClosed_subset h₂U
-    rw [supportZeroSet]
-    apply h₁f.continuousOn.preimage_isClosed_of_isClosed
-    exact IsCompact.isClosed h₂U
-    exact isClosed_singleton
-    assumption
-    assumption
-    assumption
-    exact Set.inter_subset_left
-
-  apply hinter.finite
-  apply DiscreteTopology.of_subset (s := Function.support (zeroDivisor f))
-  exact discreteZeros (f := f)
-  exact Set.inter_subset_right
-
-
-
-
-noncomputable def zeroDivisorDegree
-  {f : ℂ → ℂ}
-  {U : Set ℂ}
-  (h₁U : IsPreconnected U) -- not needed!
-  (h₂U : IsCompact U)
-  (h₁f : AnalyticOnNhd ℂ f U)
-  (h₂f : ∃ z ∈ U, f z ≠ 0) : -- not needed!
-  ℕ := (zeroDivisor_finiteOnCompact h₁U h₁f h₂f h₂U).toFinset.card
-
-
-lemma zeroDivisorDegreeZero
-  {f : ℂ → ℂ}
-  {U : Set ℂ}
-  (h₁U : IsPreconnected U) -- not needed!
-  (h₂U : IsCompact U)
-  (h₁f : AnalyticOnNhd ℂ f U)
-  (h₂f : ∃ z ∈ U, f z ≠ 0) : -- not needed!
-  0 = zeroDivisorDegree h₁U h₂U h₁f h₂f ↔ U ∩ (zeroDivisor f).support = ∅ := by
-  sorry
-
-
-lemma eliminatingZeros₀
-  {U : Set ℂ}
-  (h₁U : IsPreconnected U)
-  (h₂U : IsCompact U) :
-  ∀ n : ℕ, ∀ f : ℂ → ℂ, (h₁f : AnalyticOnNhd ℂ f U) → (h₂f : ∃ z ∈ U, f z ≠ 0) →
-  (n = zeroDivisorDegree h₁U h₂U h₁f h₂f) →
-  ∃ F : ℂ → ℂ, (AnalyticOnNhd ℂ F U) ∧ (f = F * ∏ᶠ a ∈ (U ∩ (zeroDivisor f).support), fun z ↦ (z - a) ^ (zeroDivisor f a)) := by
-
-  intro n
-  induction' n with n ih
-  -- case zero
-  intro f h₁f h₂f h₃f
-  use f
-  rw [zeroDivisorDegreeZero] at h₃f
-  rw [h₃f]
-  simpa
-
-  -- case succ
-  intro f h₁f h₂f h₃f
-
-  let Supp := (zeroDivisor_finiteOnCompact h₁U h₁f h₂f h₂U).toFinset
-
-  have : Supp.Nonempty := by
-    rw [← Finset.one_le_card]
-    calc 1
-    _ ≤ n + 1 := by exact Nat.le_add_left 1 n
-    _ = zeroDivisorDegree h₁U h₂U h₁f h₂f := by exact h₃f
-    _ = Supp.card := by rfl
-  obtain ⟨z₀, hz₀⟩ := this
-  dsimp [Supp] at hz₀
-  simp only [Set.Finite.mem_toFinset, Set.mem_inter_iff] at hz₀
-
-
-
-
-  let A := AnalyticOnNhd.order_eq_nat_iff h₁f hz₀.1 (zeroDivisor f z₀)
-  let B := zeroDivisor_eq_ord_AtZeroDivisorSupport hz₀.2
-  let B := zeroDivisor_eq_ord_AtZeroDivisorSupport' hz₀.2
-  rw [eq_comm] at B
-  let C := A B
-  obtain ⟨g₀, h₁g₀, h₂g₀, h₃g₀⟩ := C
-
-  have h₄g₀ : ∃ z ∈ U, g₀ z ≠ 0 := by sorry
-  have h₅g₀ : n = zeroDivisorDegree h₁U h₂U h₁g₀ h₄g₀ := by sorry
-
-  obtain ⟨F, h₁F, h₂F⟩ := ih g₀ h₁g₀ h₄g₀ h₅g₀
-  use F
-  constructor
-  · assumption
-  ·
-    sorry

Nevanlinna/intervalIntegrability.lean

@@ -0,0 +1,148 @@
+import Mathlib.MeasureTheory.Integral.CircleIntegral
+import Nevanlinna.periodic_integrability
+
+open scoped Interval Topology
+open Real Filter MeasureTheory intervalIntegral
+
+
+/- Integral and Integrability up to changes on codiscrete sets -/
+
+theorem d
+  {U S : Set ℂ}
+  {c : ℂ}
+  {r : ℝ}
+  (hr : r ≠ 0)
+  (hU : Metric.sphere c |r| ⊆ U)
+  (hS : S ∈ Filter.codiscreteWithin U) :
+  Countable ((circleMap c r)⁻¹' Sᶜ) := by
+
+  have : (circleMap c r)⁻¹' (S ∪ Uᶜ)ᶜ = (circleMap c r)⁻¹' Sᶜ := by
+    simp [(by simpa : (circleMap c r)⁻¹' U = ⊤)]
+  rw [← this]
+
+  apply Set.Countable.preimage_circleMap _ c hr
+  have : DiscreteTopology ((S ∪ Uᶜ)ᶜ : Set ℂ) := by
+    rw [discreteTopology_subtype_iff]
+    rw [mem_codiscreteWithin] at hS; simp at hS
+
+    intro x hx
+    rw [← mem_iff_inf_principal_compl, (by ext z; simp; tauto : S ∪ Uᶜ = (U \ S)ᶜ)]
+    rw [Set.compl_union, compl_compl] at hx
+    exact hS x hx.2
+
+  apply TopologicalSpace.separableSpace_iff_countable.1
+  exact TopologicalSpace.SecondCountableTopology.to_separableSpace
+
+
+theorem integrability_congr_changeDiscrete₀
+  {f₁ f₂ : ℂ → ℝ}
+  {U : Set ℂ}
+  {r : ℝ}
+  (hU : Metric.sphere 0 |r| ⊆ U)
+  (hf : f₁ =ᶠ[Filter.codiscreteWithin U] f₂) :
+  IntervalIntegrable (f₁ ∘ (circleMap 0 r)) MeasureTheory.volume 0 (2 * π) → IntervalIntegrable (f₂ ∘ (circleMap 0 r)) MeasureTheory.volume 0 (2 * π) := by
+  intro hf₁
+
+  by_cases hr : r = 0
+  · unfold circleMap
+    rw [hr]
+    simp
+    have : f₂ ∘ (fun (θ : ℝ) ↦ 0) = (fun r ↦ f₂ 0) := by
+      exact rfl
+    rw [this]
+    simp
+
+  · apply IntervalIntegrable.congr hf₁
+    rw [Filter.eventuallyEq_iff_exists_mem]
+    use (circleMap 0 r)⁻¹' {z | f₁ z = f₂ z}
+    constructor
+    · apply Set.Countable.measure_zero (d hr hU hf)
+    · tauto
+
+
+theorem integrability_congr_changeDiscrete
+  {f₁ f₂ : ℂ → ℝ}
+  {U : Set ℂ}
+  {r : ℝ}
+  (hU : Metric.sphere (0 : ℂ) |r| ⊆ U)
+  (hf : f₁ =ᶠ[Filter.codiscreteWithin U] f₂) :
+  IntervalIntegrable (f₁ ∘ (circleMap 0 r)) MeasureTheory.volume 0 (2 * π) ↔ IntervalIntegrable (f₂ ∘ (circleMap 0 r)) MeasureTheory.volume 0 (2 * π) := by
+
+  constructor
+  · exact integrability_congr_changeDiscrete₀ hU hf
+  · exact integrability_congr_changeDiscrete₀ hU (EventuallyEq.symm hf)
+
+
+theorem integral_congr_changeDiscrete
+  {f₁ f₂ : ℂ → ℝ}
+  {U : Set ℂ}
+  {r : ℝ}
+  (hr : r ≠ 0)
+  (hU : Metric.sphere 0 |r| ⊆ U)
+  (hf : f₁ =ᶠ[Filter.codiscreteWithin U] f₂) :
+  ∫ (x : ℝ) in (0)..(2 * π), f₁ (circleMap 0 r x) = ∫ (x : ℝ) in (0)..(2 * π), f₂ (circleMap 0 r x) := by
+
+  apply intervalIntegral.integral_congr_ae
+  rw [eventually_iff_exists_mem]
+  use (circleMap 0 r)⁻¹' {z | f₁ z = f₂ z}
+  constructor
+  · apply Set.Countable.measure_zero (d hr hU hf)
+  · tauto
+
+
+lemma circleMap_neg
+  {r x : ℝ} :
+  circleMap 0 (-r) x = circleMap 0 r (x + π) := by
+  unfold circleMap
+  simp
+  rw [add_mul]
+  rw [Complex.exp_add]
+  simp
+
+
+theorem integrability_congr_negRadius
+  {f : ℂ → ℝ}
+  {r : ℝ} :
+  IntervalIntegrable (fun (θ : ℝ) ↦ f (circleMap 0   r  θ)) MeasureTheory.volume 0 (2 * π) →
+  IntervalIntegrable (fun (θ : ℝ) ↦ f (circleMap 0 (-r) θ)) MeasureTheory.volume 0 (2 * π) := by
+
+  intro h
+  simp_rw [circleMap_neg]
+
+  let A := IntervalIntegrable.comp_add_right h π
+
+  have t₀ : Function.Periodic (fun (θ : ℝ) ↦ f (circleMap 0   r  θ)) (2 * π) := by
+    intro x
+    simp
+    congr 1
+    exact periodic_circleMap 0 r x
+  rw [← zero_add (2 * π)] at h
+  have B := periodic_integrability4 (a₁ := π) (a₂ := 3 * π) t₀ two_pi_pos h
+  let A := IntervalIntegrable.comp_add_right B π
+  simp at A
+  have : 3 * π - π = 2 * π := by
+    ring
+  rw [this] at A
+  exact A
+
+
+theorem integrabl_congr_negRadius
+  {f : ℂ → ℝ}
+  {r : ℝ} :
+  ∫ (x : ℝ) in (0)..(2 * π), f (circleMap 0 r x) = ∫ (x : ℝ) in (0)..(2 * π), f (circleMap 0 (-r) x) := by
+
+  simp_rw [circleMap_neg]
+  have t₀ : Function.Periodic (fun (θ : ℝ) ↦ f (circleMap 0   r  θ)) (2 * π) := by
+    intro x
+    simp
+    congr 1
+    exact periodic_circleMap 0 r x
+  --rw [← zero_add (2 * π)] at h
+  --have B := periodic_integrability4 (a₁ := π) (a₂ := 3 * π) t₀ two_pi_pos h
+  have B := intervalIntegral.integral_comp_add_right (a := 0) (b := 2 * π) (fun θ => f (circleMap 0 r θ)) π
+  rw [B]
+  let X := t₀.intervalIntegral_add_eq 0 (0 + π)
+  simp at X
+  rw [X]
+  simp
+  rw [add_comm]

Nevanlinna/junk/holomorphic_primitive.lean

@@ -1,666 +0,0 @@
-import Mathlib.Analysis.Complex.TaylorSeries
-import Mathlib.Analysis.SpecialFunctions.Integrals
-import Mathlib.MeasureTheory.Integral.DivergenceTheorem
-import Mathlib.MeasureTheory.Integral.IntervalIntegral
-import Mathlib.MeasureTheory.Function.LocallyIntegrable
-import Nevanlinna.partialDeriv
-import Nevanlinna.cauchyRiemann
-
-/-
-noncomputable def partialDeriv
-  {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
-  {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F] : E → (E → F) → (E → F) :=
-  fun v ↦ (fun f ↦ (fun w ↦ fderiv ℝ f w v))
-
-
-theorem partialDeriv_compContLinAt 
-  {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
-  {F : Type*} [NormedAddCommGroup F] [NormedSpace ℂ F]
-  {G : Type*} [NormedAddCommGroup G] [NormedSpace ℂ G]
-  {f : E → F} 
-  {l : F →L[ℝ] G} 
-  {v : E} 
-  {x : E} 
-  (h : DifferentiableAt ℝ f x) :
-  (partialDeriv v (l ∘ f)) x = (l ∘ partialDeriv v f) x:= by
-  unfold partialDeriv
-  rw [fderiv.comp x (ContinuousLinearMap.differentiableAt l) h]
-  simp
-
-
-theorem partialDeriv_compCLE
-  {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
-  {F : Type*} [NormedAddCommGroup F] [NormedSpace ℂ F]
-  {G : Type*} [NormedAddCommGroup G] [NormedSpace ℂ G]
-  {f : E → F}
-  {l : F ≃L[ℝ] G} {v : E} : partialDeriv v (l ∘ f) = l ∘ partialDeriv v f := by
-  funext x
-  by_cases hyp : DifferentiableAt ℝ f x
-  · let lCLM : F →L[ℝ] G := l
-    suffices shyp : partialDeriv v (lCLM ∘ f) x = (lCLM ∘ partialDeriv v f) x from by tauto
-    apply partialDeriv_compContLinAt
-    exact hyp
-  · unfold partialDeriv
-    rw [fderiv_zero_of_not_differentiableAt]
-    simp
-    rw [fderiv_zero_of_not_differentiableAt]
-    simp
-    exact hyp
-    rw [ContinuousLinearEquiv.comp_differentiableAt_iff]
-    exact hyp
-
-theorem partialDeriv_smul'₂
-  {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
-  {F : Type*} [NormedAddCommGroup F] [NormedSpace ℂ F]
-  {f : E → F} {a : ℂ} {v : E} :
-  partialDeriv v (a • f) = a • partialDeriv v f := by
-
-  funext w
-  by_cases ha : a = 0
-  · unfold partialDeriv
-    have : a • f = fun y ↦ a • f y := by rfl
-    rw [this, ha]
-    simp
-  · -- Now a is not zero. We present scalar multiplication with a as a continuous linear equivalence.
-    let smulCLM : F ≃L[ℝ] F :=
-    {
-      toFun := fun x ↦ a • x
-      map_add' := fun x y => DistribSMul.smul_add a x y
-      map_smul' := fun m x => (smul_comm ((RingHom.id ℝ) m) a x).symm
-      invFun := fun x ↦ a⁻¹ • x
-      left_inv := by
-        intro x
-        simp
-        rw [← smul_assoc, smul_eq_mul, mul_comm, mul_inv_cancel ha, one_smul]
-      right_inv := by
-        intro x
-        simp
-        rw [← smul_assoc, smul_eq_mul, mul_inv_cancel ha, one_smul]
-      continuous_toFun := continuous_const_smul a
-      continuous_invFun := continuous_const_smul a⁻¹
-    }
-
-    have : a • f = smulCLM ∘ f := by tauto
-    rw [this]
-    rw [partialDeriv_compCLE]
-    tauto
-
-theorem CauchyRiemann₄
-  {F : Type*} [NormedAddCommGroup F] [NormedSpace ℂ F] 
-  {f : ℂ → F} : 
-  (Differentiable ℂ f) → partialDeriv ℝ Complex.I f = Complex.I • partialDeriv ℝ 1 f := by
-  intro h
-  unfold partialDeriv
-
-  conv =>
-    left
-    intro w
-    rw [DifferentiableAt.fderiv_restrictScalars ℝ (h w)]
-    simp
-    rw [← mul_one Complex.I]
-    rw [← smul_eq_mul]
-  conv =>
-    right
-    right
-    intro w
-    rw [DifferentiableAt.fderiv_restrictScalars ℝ (h w)]
-  funext w
-  simp
--/
-
-
-theorem MeasureTheory.integral2_divergence₃
-  {E : Type u} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
-  (f g : ℝ × ℝ → E)
-  (h₁f : ContDiff ℝ 1 f)
-  (h₁g : ContDiff ℝ 1 g)
-  (a₁ : ℝ)
-  (a₂ : ℝ)
-  (b₁ : ℝ)
-  (b₂ : ℝ) :
-  ∫ (x : ℝ) in a₁..b₁, ∫ (y : ℝ) in a₂..b₂, ((fderiv ℝ f) (x, y)) (1, 0) + ((fderiv ℝ g) (x, y)) (0, 1) = (((∫ (x : ℝ) in a₁..b₁, g (x, b₂)) - ∫ (x : ℝ) in a₁..b₁, g (x, a₂)) + ∫ (y : ℝ) in a₂..b₂, f (b₁, y)) - ∫ (y : ℝ) in a₂..b₂, f (a₁, y) := by
-
-  apply integral2_divergence_prod_of_hasFDerivWithinAt_off_countable f g (fderiv ℝ f) (fderiv ℝ g) a₁ a₂ b₁ b₂ ∅
-  exact Set.countable_empty
-  -- ContinuousOn f (Set.uIcc a₁ b₁ ×ˢ Set.uIcc a₂ b₂)
-  exact h₁f.continuous.continuousOn
-  --
-  exact h₁g.continuous.continuousOn
-  --
-  rw [Set.diff_empty]
-  intro x _
-  exact DifferentiableAt.hasFDerivAt ((h₁f.differentiable le_rfl) x)
-  --
-  rw [Set.diff_empty]
-  intro y _
-  exact DifferentiableAt.hasFDerivAt ((h₁g.differentiable le_rfl) y)
-  --
-  apply ContinuousOn.integrableOn_compact
-  apply IsCompact.prod
-  exact isCompact_uIcc
-  exact isCompact_uIcc
-  apply ContinuousOn.add
-  apply Continuous.continuousOn
-  exact Continuous.clm_apply (ContDiff.continuous_fderiv h₁f le_rfl) continuous_const
-  apply Continuous.continuousOn
-  exact Continuous.clm_apply (ContDiff.continuous_fderiv h₁g le_rfl) continuous_const
-
-
-theorem integral_divergence₄
-  {E : Type u} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E]
-  (f g : ℂ  → E)
-  (h₁f : ContDiff ℝ 1 f)
-  (h₁g : ContDiff ℝ 1 g)
-  (a₁ : ℝ)
-  (a₂ : ℝ)
-  (b₁ : ℝ)
-  (b₂ : ℝ) :
-  ∫ (x : ℝ) in a₁..b₁, ∫ (y : ℝ) in a₂..b₂, ((fderiv ℝ f) ⟨x, y⟩ ) 1 + ((fderiv ℝ g) ⟨x, y⟩) Complex.I = (((∫ (x : ℝ) in a₁..b₁, g ⟨x, b₂⟩) - ∫ (x : ℝ) in a₁..b₁, g ⟨x, a₂⟩) + ∫ (y : ℝ) in a₂..b₂, f ⟨b₁, y⟩) - ∫ (y : ℝ) in a₂..b₂, f ⟨a₁, y⟩ := by
-
-  let fr : ℝ × ℝ → E := f ∘ Complex.equivRealProdCLM.symm
-  let gr : ℝ × ℝ → E := g ∘ Complex.equivRealProdCLM.symm
-
-  have sfr {x y : ℝ} : f { re := x, im := y } = fr (x, y) := by exact rfl
-  have sgr {x y : ℝ} : g { re := x, im := y } = gr (x, y) := by exact rfl
-  repeat (conv in f { re := _, im := _ } => rw [sfr])
-  repeat (conv in g { re := _, im := _ } => rw [sgr])
-
-  have sfr' {x y : ℝ} {z : ℂ} : (fderiv ℝ f { re := x, im := y }) z = fderiv ℝ fr (x, y) (Complex.equivRealProdCLM z) := by
-    rw [fderiv.comp]
-    rw [Complex.equivRealProdCLM.symm.fderiv]
-    tauto
-    apply Differentiable.differentiableAt
-    exact h₁f.differentiable le_rfl
-    exact Complex.equivRealProdCLM.symm.differentiableAt
-  conv in ⇑(fderiv ℝ f { re := _, im := _ }) _ => rw [sfr']
-
-  have sgr' {x y : ℝ} {z : ℂ} : (fderiv ℝ g { re := x, im := y }) z = fderiv ℝ gr (x, y) (Complex.equivRealProdCLM z) := by
-    rw [fderiv.comp]
-    rw [Complex.equivRealProdCLM.symm.fderiv]
-    tauto
-    apply Differentiable.differentiableAt
-    exact h₁g.differentiable le_rfl
-    exact Complex.equivRealProdCLM.symm.differentiableAt
-  conv in ⇑(fderiv ℝ g { re := _, im := _ }) _ => rw [sgr']
-
-  apply MeasureTheory.integral2_divergence₃ fr gr _ _ a₁ a₂ b₁ b₂
-  -- ContDiff ℝ 1 fr
-  exact (ContinuousLinearEquiv.contDiff_comp_iff (ContinuousLinearEquiv.symm Complex.equivRealProdCLM)).mpr h₁f
-  -- ContDiff ℝ 1 gr
-  exact (ContinuousLinearEquiv.contDiff_comp_iff (ContinuousLinearEquiv.symm Complex.equivRealProdCLM)).mpr h₁g
-
-
-theorem integral_divergence₅
-  {E : Type u} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
-  (F : ℂ  → E)
-  (hF : Differentiable ℂ F)
-  (lowerLeft upperRight : ℂ) :
-  (∫ (x : ℝ) in lowerLeft.re..upperRight.re, F ⟨x, lowerLeft.im⟩)  + Complex.I • ∫ (x : ℝ) in lowerLeft.im..upperRight.im, F ⟨upperRight.re, x⟩ =
-  (∫ (x : ℝ) in lowerLeft.re..upperRight.re, F ⟨x, upperRight.im⟩) + Complex.I • ∫ (x : ℝ) in lowerLeft.im..upperRight.im, F ⟨lowerLeft.re,  x⟩ := by
-
-  let h₁f : ContDiff ℝ 1 F := (hF.contDiff : ContDiff ℂ 1 F).restrict_scalars ℝ
-
-  let h₁g : ContDiff ℝ 1 (-Complex.I • F) := by
-    have : -Complex.I • F = fun x ↦ -Complex.I • F x := by rfl
-    rw [this]
-    apply ContDiff.comp
-    exact contDiff_const_smul _
-    exact h₁f  
-
-  let A := integral_divergence₄ (-Complex.I • F) F h₁g h₁f lowerLeft.re upperRight.im upperRight.re lowerLeft.im
-  have {z : ℂ} : fderiv ℝ F z Complex.I = partialDeriv ℝ Complex.I F z := by rfl
-  conv at A in (fderiv ℝ F _) _ => rw [this]
-  have {z : ℂ} : fderiv ℝ (-Complex.I • F) z 1 = partialDeriv ℝ 1 (-Complex.I • F) z := by rfl
-  conv at A in (fderiv ℝ (-Complex.I • F) _) _ => rw [this]
-  conv at A =>
-    left
-    arg 1
-    intro x
-    arg 1
-    intro y
-    rw [CauchyRiemann₄ hF]
-    rw [partialDeriv_smul'₂]
-    simp
-  simp at A
-
-  have {t₁ t₂ t₃ t₄ : E} : 0 = (t₁ - t₂) + t₃ + t₄ → t₁ + t₃ = t₂ - t₄ := by
-    intro hyp
-    calc
-      t₁ + t₃ = t₁ + t₃ - 0 := by rw [sub_zero (t₁ + t₃)]
-      _ = t₁ + t₃ - (t₁ - t₂ + t₃ + t₄) := by rw [hyp]
-      _ = t₂ - t₄ := by abel
-  let B := this A
-  repeat
-    rw [intervalIntegral.integral_symm lowerLeft.im upperRight.im] at B
-  simp at B
-  exact B
-
-
-noncomputable def primitive
-  {E : Type u} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E] :
-  ℂ  → (ℂ → E) → (ℂ → E) := by
-  intro z₀
-  intro f
-  exact fun z ↦ (∫ (x : ℝ) in z₀.re..z.re, f ⟨x, z₀.im⟩) + Complex.I • ∫ (x : ℝ) in z₀.im..z.im, f ⟨z.re, x⟩
-
-
-theorem primitive_zeroAtBasepoint
-  {E : Type u} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
-  (f : ℂ  → E)
-  (z₀ : ℂ) :
-  (primitive z₀ f) z₀ = 0 := by
-  unfold primitive
-  simp
-
-
-theorem primitive_fderivAtBasepointZero
-  {E : Type u} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
-  (f : ℂ  → E)
-  (hf : Continuous f) :
-  HasDerivAt (primitive 0 f) (f 0) 0 := by
-  unfold primitive
-  simp
-  apply hasDerivAt_iff_isLittleO.2
-  simp
-  rw [Asymptotics.isLittleO_iff]
-  intro c hc
-
-  have {z : ℂ} {e : E} : z • e = (∫ (_ : ℝ) in (0)..(z.re), e) + Complex.I • ∫ (_ : ℝ) in (0)..(z.im), e:= by
-    simp
-    rw [smul_comm]
-    rw [← smul_assoc]
-    simp
-    have : z.re • e = (z.re : ℂ) • e := by exact rfl
-    rw [this, ← add_smul]
-    simp
-  conv =>
-    left
-    intro x
-    left
-    arg 1
-    arg 2
-    rw [this]
-  have {A B C D :E} : (A + B) - (C + D) = (A - C) + (B - D) := by
-    abel
-  have t₀ {r : ℝ} : IntervalIntegrable (fun x => f { re := x, im := 0 }) MeasureTheory.volume 0 r := by
-    apply Continuous.intervalIntegrable
-    apply Continuous.comp
-    exact hf
-    have : (fun x => ({ re := x, im := 0 } : ℂ)) = Complex.ofRealLI := by rfl
-    rw [this]
-    continuity
-  have t₁ {r : ℝ} : IntervalIntegrable (fun _ => f 0) MeasureTheory.volume 0 r := by
-    apply Continuous.intervalIntegrable
-    apply Continuous.comp
-    exact hf
-    fun_prop
-  have t₂ {a b : ℝ} : IntervalIntegrable (fun x_1 => f { re := a, im := x_1 }) MeasureTheory.volume 0 b := by
-    apply Continuous.intervalIntegrable
-    apply Continuous.comp hf
-    have : (Complex.mk a) = (fun x => Complex.I • Complex.ofRealCLM x + { re := a, im := 0 }) := by
-      funext x
-      apply Complex.ext
-      rw [Complex.add_re]
-      simp
-      simp
-    rw [this]
-    apply Continuous.add
-    continuity
-    fun_prop
-
-  have t₃ {a : ℝ} : IntervalIntegrable (fun _ => f 0) MeasureTheory.volume 0 a := by
-    apply Continuous.intervalIntegrable
-    apply Continuous.comp
-    exact hf
-    fun_prop
-  conv =>
-    left
-    intro x
-    left
-    arg 1
-    rw [this]
-    rw [← smul_sub]
-    rw [← intervalIntegral.integral_sub t₀ t₁]
-    rw [← intervalIntegral.integral_sub t₂ t₃]
-  rw [Filter.eventually_iff_exists_mem]
-
-  let s := f⁻¹' Metric.ball (f 0) (c / (4 : ℝ))
-  have h₁s : IsOpen s := IsOpen.preimage hf Metric.isOpen_ball
-  have h₂s : 0 ∈ s := by
-    apply Set.mem_preimage.mpr
-    apply Metric.mem_ball_self
-    linarith
-
-  obtain ⟨ε, h₁ε, h₂ε⟩ := Metric.isOpen_iff.1 h₁s 0 h₂s
-
-  have h₃ε : ∀ y ∈ Metric.ball 0 ε, ‖(f y) - (f 0)‖ < (c / (4 : ℝ)) := by
-    intro y hy
-    apply mem_ball_iff_norm.mp (h₂ε hy)
-
-  use Metric.ball 0 (ε / (4 : ℝ))
-  constructor
-  · apply Metric.ball_mem_nhds 0
-    linarith
-  · intro y hy
-    have h₁y : |y.re| < ε / 4 := by
-      calc |y.re|
-      _ ≤ Complex.abs y := by apply Complex.abs_re_le_abs
-      _ < ε / 4 := by
-        let A := mem_ball_iff_norm.1 hy
-        simp at A
-        linarith
-    have h₂y : |y.im| < ε / 4 := by
-      calc |y.im|
-      _ ≤ Complex.abs y := by apply Complex.abs_im_le_abs
-      _ < ε / 4 := by
-        let A := mem_ball_iff_norm.1 hy
-        simp at A
-        linarith
-
-    have intervalComputation {x' y' : ℝ} (h : x' ∈ Ι 0 y') : |x'| ≤ |y'| := by
-      let A := h.1
-      let B := h.2
-      rcases le_total 0 y' with hy | hy
-      · simp [hy] at A
-        simp [hy] at B
-        rw [abs_of_nonneg hy]
-        rw [abs_of_nonneg (le_of_lt A)]
-        exact B
-      · simp [hy] at A
-        simp [hy] at B
-        rw [abs_of_nonpos hy]
-        rw [abs_of_nonpos]
-        linarith [h.1]
-        exact B
-
-    have t₁ : ‖(∫ (x : ℝ) in (0)..(y.re), f { re := x, im := 0 } - f 0)‖ ≤ (c / (4 : ℝ)) * |y.re - 0| := by
-      apply intervalIntegral.norm_integral_le_of_norm_le_const
-      intro x hx
-
-      have h₁x : |x| < ε / 4 := by
-        calc |x|
-          _ ≤ |y.re| := intervalComputation hx
-          _ < ε / 4 := h₁y
-      apply le_of_lt
-      apply h₃ε { re := x, im := 0 }
-      rw [mem_ball_iff_norm]
-      simp
-      have : { re := x, im := 0 } = (x : ℂ) := by rfl
-      rw [this]
-      rw [Complex.abs_ofReal]
-      linarith
-
-    have t₂ : ‖∫ (x : ℝ) in (0)..(y.im), f { re := y.re, im := x } - f 0‖ ≤ (c / (4 : ℝ)) * |y.im - 0| := by
-      apply intervalIntegral.norm_integral_le_of_norm_le_const
-      intro x hx
-
-      have h₁x : |x| < ε / 4 := by
-        calc |x|
-          _ ≤ |y.im| := intervalComputation hx
-          _ < ε / 4 := h₂y
-
-      apply le_of_lt
-      apply h₃ε { re := y.re, im := x }
-      simp
-
-      calc Complex.abs { re := y.re, im := x }
-        _ ≤ |y.re| + |x| := by
-          apply Complex.abs_le_abs_re_add_abs_im { re := y.re, im := x }
-        _ < ε := by
-          linarith
-
-    calc ‖(∫ (x : ℝ) in (0)..(y.re), f { re := x, im := 0 } - f 0) + Complex.I • ∫ (x : ℝ) in (0)..(y.im), f { re := y.re, im := x } - f 0‖
-      _ ≤ ‖(∫ (x : ℝ) in (0)..(y.re), f { re := x, im := 0 } - f 0)‖ + ‖Complex.I • ∫ (x : ℝ) in (0)..(y.im), f { re := y.re, im := x } - f 0‖ := by
-        apply norm_add_le
-      _ ≤ ‖(∫ (x : ℝ) in (0)..(y.re), f { re := x, im := 0 } - f 0)‖ + ‖∫ (x : ℝ) in (0)..(y.im), f { re := y.re, im := x } - f 0‖ := by
-        simp
-        rw [norm_smul]
-        simp
-      _ ≤ (c / (4 : ℝ)) * |y.re - 0| + (c / (4 : ℝ)) * |y.im - 0| := by
-        apply add_le_add
-        exact t₁
-        exact t₂
-      _ ≤ (c / (4 : ℝ)) * (|y.re| + |y.im|) := by
-        simp
-        rw [mul_add]
-      _ ≤ (c / (4 : ℝ)) * (4 * ‖y‖) := by
-        have : |y.re| + |y.im| ≤ 4 * ‖y‖ := by
-          calc |y.re| + |y.im|
-            _ ≤ ‖y‖ + ‖y‖ := by
-              apply add_le_add
-              apply Complex.abs_re_le_abs
-              apply Complex.abs_im_le_abs
-            _ ≤ 4 * ‖y‖ := by
-              rw [← two_mul]
-              apply mul_le_mul
-              linarith
-              rfl
-              exact norm_nonneg y
-              linarith
-
-        apply mul_le_mul
-        rfl
-        exact this
-        apply add_nonneg
-        apply abs_nonneg
-        apply abs_nonneg
-        linarith
-      _ ≤ c * ‖y‖ := by
-        linarith
-
-
-theorem primitive_translation
-  {E : Type u} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
-  (f : ℂ  → E)
-  (z₀ t : ℂ) :
-  primitive z₀ (f ∘ fun z ↦ (z - t)) = ((primitive (z₀ - t) f) ∘ fun z ↦ (z - t)) := by
-  funext z
-  unfold primitive
-  simp
-
-  let g : ℝ → E := fun x ↦ f ( {re := x, im := z₀.im - t.im} )
-  have {x : ℝ} : f ({ re := x, im := z₀.im } - t) = g (1*x - t.re) := by
-    congr 1
-    apply Complex.ext <;> simp
-  conv =>
-    left
-    left
-    arg 1
-    intro x
-    rw [this]
-  rw [intervalIntegral.integral_comp_mul_sub g one_ne_zero (t.re)]
-  simp
-
-  congr 1
-  let g : ℝ → E := fun x ↦ f ( {re := z.re - t.re, im := x} )
-  have {x : ℝ} : f ({ re := z.re, im := x} - t) = g (1*x - t.im) := by
-    congr 1
-    apply Complex.ext <;> simp
-  conv =>
-    left
-    arg 1
-    intro x
-    rw [this]
-  rw [intervalIntegral.integral_comp_mul_sub g one_ne_zero (t.im)]
-  simp
-
-
-theorem primitive_hasDerivAtBasepoint
-  {E : Type u} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
-  {f : ℂ  → E}
-  (hf : Continuous f)   
-  (z₀ : ℂ) :
-  HasDerivAt (primitive z₀ f) (f z₀) z₀ := by
-
-  let g := f ∘ fun z ↦ z + z₀
-  have : Continuous g := by continuity
-  let A := primitive_fderivAtBasepointZero g this
-  simp at A
-
-  let B := primitive_translation g z₀ z₀
-  simp at B
-  have : (g ∘ fun z ↦ (z - z₀)) = f := by
-    funext z
-    dsimp [g]
-    simp
-  rw [this] at B
-  rw [B]
-  have : f z₀ = (1 : ℂ) • (f z₀) := by
-    exact (MulAction.one_smul (f z₀)).symm
-  conv =>
-    arg 2
-    rw [this]
-
-  apply HasDerivAt.scomp
-  simp
-  have : g 0 = f z₀ := by simp [g]
-  rw [← this]
-  exact A
-  apply HasDerivAt.sub_const
-  have : (fun (x : ℂ) ↦ x) = id := by
-    funext x
-    simp
-  rw [this]
-  exact hasDerivAt_id z₀
-
-
-lemma integrability₁
-  {E : Type u} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
-  (f : ℂ  → E)
-  (hf : Differentiable ℂ f)
-  (a₁ a₂ b : ℝ) :
-  IntervalIntegrable (fun x => f { re := x, im := b }) MeasureTheory.volume a₁ a₂ := by
-  apply Continuous.intervalIntegrable
-  apply Continuous.comp
-  exact Differentiable.continuous hf
-  have : ((fun x => { re := x, im := b }) : ℝ → ℂ) = (fun x => Complex.ofRealCLM x + { re := 0, im := b }) := by
-    funext x
-    apply Complex.ext
-    rw [Complex.add_re]
-    simp
-    rw [Complex.add_im]
-    simp
-  rw [this]
-  continuity
-
-
-lemma integrability₂
-  {E : Type u} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
-  (f : ℂ  → E)
-  (hf : Differentiable ℂ f)
-  (a₁ a₂ b : ℝ) :
-  IntervalIntegrable (fun x => f { re := b, im := x }) MeasureTheory.volume a₁ a₂ := by
-  apply Continuous.intervalIntegrable
-  apply Continuous.comp
-  exact Differentiable.continuous hf
-  have : (Complex.mk b) = (fun x => Complex.I • Complex.ofRealCLM x + { re := b, im := 0 }) := by
-    funext x
-    apply Complex.ext
-    rw [Complex.add_re]
-    simp
-    simp
-  rw [this]
-  apply Continuous.add
-  continuity
-  fun_prop
-
-
-theorem primitive_additivity
-  {E : Type u} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
-  (f : ℂ  → E)
-  (hf : Differentiable ℂ f)
-  (z₀ z₁ : ℂ) :
-  primitive z₀ f = fun z ↦ (primitive z₁ f) z + (primitive z₀ f z₁) := by
-  funext z
-  unfold primitive
-
-  have : (∫ (x : ℝ) in z₀.re..z.re, f { re := x, im := z₀.im }) = (∫ (x : ℝ) in z₀.re..z₁.re, f { re := x, im := z₀.im }) + (∫ (x : ℝ) in z₁.re..z.re, f { re := x, im := z₀.im }) := by
-    rw [intervalIntegral.integral_add_adjacent_intervals]   
-    apply integrability₁ f hf 
-    apply integrability₁ f hf 
-  rw [this]
-
-  have : (∫ (x : ℝ) in z₀.im..z.im, f { re := z.re, im := x }) = (∫ (x : ℝ) in z₀.im..z₁.im, f { re := z.re, im := x }) + (∫ (x : ℝ) in z₁.im..z.im, f { re := z.re, im := x }) := by
-    rw [intervalIntegral.integral_add_adjacent_intervals]
-    apply integrability₂ f hf 
-    apply integrability₂ f hf 
-  rw [this]
-  simp
-
-  let A := integral_divergence₅ f hf ⟨z₁.re, z₀.im⟩ ⟨z.re, z₁.im⟩
-  simp at A
-
-  have {a b c d : E} : (b + a) + (c + d) = (a + c) + (b + d) := by
-    abel
-  rw [this]
-  rw [A]
-  abel
-
-
-theorem primitive_hasDerivAt
-  {E : Type u} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
-  {f : ℂ  → E}
-  (hf : Differentiable ℂ f)
-  (z₀ z : ℂ) :
-  HasDerivAt (primitive z₀ f) (f z) z := by
-  rw [primitive_additivity f hf z₀ z]
-  rw [← add_zero (f z)]
-  apply HasDerivAt.add
-  apply primitive_hasDerivAtBasepoint
-  exact hf.continuous
-  apply hasDerivAt_const
-
-
-theorem primitive_differentiable
-  {E : Type u} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
-  {f : ℂ  → E}
-  (hf : Differentiable ℂ f)
-  (z₀ : ℂ) :
-  Differentiable ℂ (primitive z₀ f) := by
-  intro z
-  exact (primitive_hasDerivAt hf z₀ z).differentiableAt 
-
-
-theorem primitive_hasFderivAt
-  {E : Type u} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
-  {f : ℂ  → E}
-  (hf : Differentiable ℂ f)
-  (z₀ : ℂ) :
-  ∀ z, HasFDerivAt (primitive z₀ f) ((ContinuousLinearMap.lsmul ℂ ℂ).flip (f z)) z := by
-  intro z
-  rw [hasFDerivAt_iff_hasDerivAt]
-  simp    
-  exact primitive_hasDerivAt hf z₀ z
-
-
-theorem primitive_hasFderivAt'
-  {f : ℂ  → ℂ}
-  (hf : Differentiable ℂ f)
-  (z₀ : ℂ) :
-  ∀ z, HasFDerivAt (primitive z₀ f) (ContinuousLinearMap.lsmul ℂ ℂ (f z)) z := by
-  intro z
-  rw [hasFDerivAt_iff_hasDerivAt]
-  simp    
-  exact primitive_hasDerivAt hf z₀ z
-
-
-theorem primitive_fderiv
-  {E : Type u} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
-  {f : ℂ  → E}
-  (hf : Differentiable ℂ f)
-  (z₀ : ℂ) :
-  ∀ z, (fderiv ℂ (primitive z₀ f) z) = (ContinuousLinearMap.lsmul ℂ ℂ).flip (f z) := by
-  intro z
-  apply HasFDerivAt.fderiv
-  exact primitive_hasFderivAt hf z₀ z
-
-
-theorem primitive_fderiv'
-  {f : ℂ  → ℂ}
-  (hf : Differentiable ℂ f)
-  (z₀ : ℂ) :
-  ∀ z, (fderiv ℂ (primitive z₀ f) z) = ContinuousLinearMap.lsmul ℂ ℂ (f z) := by
-  intro z
-  apply HasFDerivAt.fderiv
-  exact primitive_hasFderivAt' hf z₀ z
-

Nevanlinna/junk/laplace2.lean

@@ -1,285 +0,0 @@
-import Mathlib.Analysis.InnerProductSpace.Basic
-import Mathlib.Analysis.InnerProductSpace.Dual
-import Mathlib.Analysis.InnerProductSpace.PiL2
---import Mathlib.Algebra.BigOperators.Basic
-import Mathlib.Analysis.Calculus.ContDiff.Bounds
-import Mathlib.Analysis.Calculus.FDeriv.Symmetric
---import Mathlib.LinearAlgebra.Basis
---import Mathlib.LinearAlgebra.Contraction
-
-open BigOperators
-open Finset
-
-
-variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E]
-
-noncomputable def realInnerAsElementOfDualTensorprod
-  {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
-  : TensorProduct ℝ E E →ₗ[ℝ] ℝ := TensorProduct.lift bilinFormOfRealInner
-
-
-instance
-  {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]  [FiniteDimensional ℝ E]
-  : NormedAddCommGroup (TensorProduct ℝ E E) where
-    norm := by
-
-      sorry
-    dist_self := by
-
-      sorry
-
-  sorry
-
-/-
-instance
-  {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]  [FiniteDimensional ℝ E]
-  : InnerProductSpace ℝ (TensorProduct ℝ E E) where
-    smul := _
-    one_smul := _
-    mul_smul := _
-    smul_zero := _
-    smul_add := _
-    add_smul := _
-    zero_smul := _
-    norm_smul_le := _
-    inner := _
-    norm_sq_eq_inner := _
-    conj_symm := _
-    add_left := _
-    smul_left := _
-  -/
-
-
-
-noncomputable def dual'
-  {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [CompleteSpace E]  [FiniteDimensional ℝ E]
-  : (TensorProduct ℝ E E →ₗ[ℝ] ℝ) ≃ₗ[ℝ] TensorProduct ℝ E E := by
-
-  let d := InnerProductSpace.toDual ℝ E
-
-
-  let e := d.toLinearEquiv
-
-  let a := TensorProduct.congr e e
-
-  let b := homTensorHomEquiv ℝ E E ℝ ℝ
-
-  sorry
-
-
-variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E]
-variable {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F]
-
-
-theorem InvariantTensor
-  [Fintype ι]
-  (v : Basis ι ℝ E)
-  (c : ι → ℝ)
-  (L : ContinuousMultilinearMap ℝ (fun (_ : Fin 2) ↦ E) F) :
-  L (fun _ => ∑ j : ι, c j • v j) = ∑ x : Fin 2 → ι, (c (x 0) * c (x 1)) • L ((fun i => v (x i))) := by
-
-  rw [L.map_sum]
-  simp_rw [L.map_smul_univ]
-  sorry
-
-
-
-theorem BilinearCalc
-  [Fintype ι]
-  (v : Basis ι ℝ E)
-  (c : ι → ℝ)
-  (L : ContinuousMultilinearMap ℝ (fun (_ : Fin 2) ↦ E) F) :
-  L (fun _ => ∑ j : ι, c j • v j) = ∑ x : Fin 2 → ι, (c (x 0) * c (x 1)) • L ((fun i => v (x i))) := by
-
-  rw [L.map_sum]
-  simp_rw [L.map_smul_univ]
-  sorry
-
-/-
-lemma c2
-  [Fintype ι]
-  (b : Basis ι ℝ E)
-  (hb : Orthonormal ℝ b)
-  (x y : E) :
-  ⟪x, y⟫_ℝ = ∑ i : ι, ⟪x, b i⟫_ℝ * ⟪y, b i⟫_ℝ := by
-  rw [vectorPresentation b hb x]
-  rw [vectorPresentation b hb y]
-  rw [Orthonormal.inner_sum hb]
-  simp
-  conv =>
-    right
-    arg 2
-    intro i'
-    rw [Orthonormal.inner_left_fintype hb]
-    rw [Orthonormal.inner_left_fintype hb]
--/
-
-lemma fin_sum
-  [Fintype ι]
-  (f : ι → ι → F) :
-  ∑ r : Fin 2 → ι, f (r 0) (r 1) = ∑ r₀ : ι, (∑ r₁ : ι, f r₀ r₁) := by
-
-  rw [← Fintype.sum_prod_type']
-  apply Fintype.sum_equiv (finTwoArrowEquiv ι)
-  intro x
-  dsimp
-
-
-theorem LaplaceIndep
-  [Fintype ι] [DecidableEq ι]
-  (v₁ : OrthonormalBasis ι ℝ E)
-  (v₂ : OrthonormalBasis ι ℝ E)
-  (L : ContinuousMultilinearMap ℝ (fun (_ : Fin 2) ↦ E) F) :
-  ∑ i, L (fun _ ↦ v₁ i) = ∑ i, L (fun _ => v₂ i) := by
-
-  have vector_vs_function
-    {y : Fin 2 → ι}
-    {v : ι → E}
-    : (fun i => v (y i)) = ![v (y 0), v (y 1)] := by
-    funext i
-    by_cases h : i = 0
-    · rw [h]
-      simp
-    · rw [Fin.eq_one_of_neq_zero i h]
-      simp
-
-  conv =>
-    right
-    arg 2
-    intro i
-    rw [v₁.sum_repr' (v₂ i)]
-    rw [BilinearCalc]
-  rw [Finset.sum_comm]
-  conv =>
-    right
-    arg 2
-    intro y
-    rw [← Finset.sum_smul]
-    rw [← c2 v₂ hv₂ (v₁ (y 0)) (v₁ (y 1))]
-    rw [vector_vs_function]
-  simp
-
-  rw [fin_sum (fun i₀ ↦ (fun i₁ ↦ ⟪v₁ i₀, v₁ i₁⟫_ℝ • L ![v₁ i₀, v₁ i₁]))]
-
-  have xx {r₀ : ι} : ∀ r₁ : ι, r₁ ≠ r₀ → ⟪v₁ r₀, v₁ r₁⟫_ℝ • L ![v₁ r₀, v₁ r₁] = 0 := by
-    intro r₁ hr₁
-    rw [orthonormal_iff_ite.1 hv₁]
-    simp
-    tauto
-
-  conv =>
-    right
-    arg 2
-    intro r₀
-    rw [Fintype.sum_eq_single r₀ xx]
-    rw [orthonormal_iff_ite.1 hv₁]
-  apply sum_congr
-  rfl
-  intro x _
-  rw [vector_vs_function]
-  simp
-
-
-noncomputable def Laplace_wrt_basis
-  [Fintype ι]
-  (v : Basis ι ℝ E)
-  (_ : Orthonormal ℝ v)
-  (f : E → F) :
-  E → F :=
-  fun z ↦ ∑ i, iteratedFDeriv ℝ 2 f z ![v i, v i]
-
-
-theorem LaplaceIndep'
-  [Fintype ι] [DecidableEq ι]
-  (v₁ : OrthonormalBasis ι ℝ E)
-  (v₂ : OrthonormalBasis ι ℝ E)
-  (f : E → F)
-  : (Laplace_wrt_basis v₁ hv₁ f) = (Laplace_wrt_basis v₂ hv₂ f) := by
-
-  funext z
-  unfold Laplace_wrt_basis
-  let XX := LaplaceIndep v₁ hv₁ v₂ hv₂ (iteratedFDeriv ℝ 2 f z)
-  have vector_vs_function
-    {v : E}
-    : ![v, v] = (fun _ => v) := by
-    funext i
-    by_cases h : i = 0
-    · rw [h]
-      simp
-    · rw [Fin.eq_one_of_neq_zero i h]
-      simp
-  conv =>
-    left
-    arg 2
-    intro i
-    rw [vector_vs_function]
-  conv =>
-    right
-    arg 2
-    intro i
-    rw [vector_vs_function]
-  assumption
-
-
-theorem LaplaceIndep''
-  [Fintype ι₁] [DecidableEq ι₁]
-  (v₁ : Basis ι₁ ℝ E)
-  (hv₁ : Orthonormal ℝ v₁)
-  [Fintype ι₂] [DecidableEq ι₂]
-  (v₂ : Basis ι₂ ℝ E)
-  (hv₂ : Orthonormal ℝ v₂)
-  (f : E → F)
-  : (Laplace_wrt_basis v₁ hv₁ f) = (Laplace_wrt_basis v₂ hv₂ f) := by
-
-  have b : ι₁ ≃ ι₂ := by
-    apply Fintype.equivOfCardEq
-    rw [← FiniteDimensional.finrank_eq_card_basis v₁]
-    rw [← FiniteDimensional.finrank_eq_card_basis v₂]
-
-  let v'₁ := Basis.reindex v₁ b
-  have hv'₁ : Orthonormal ℝ v'₁ := by
-    let A := Basis.reindex_apply v₁ b
-    have : ⇑v'₁ = v₁ ∘ b.symm := by
-      funext i
-      exact A i
-    rw [this]
-    let B := Orthonormal.comp hv₁ b.symm
-    apply B
-    exact Equiv.injective b.symm
-  rw [← LaplaceIndep' v'₁ hv'₁ v₂ hv₂ f]
-
-  unfold Laplace_wrt_basis
-  simp
-  funext z
-
-  rw [← Equiv.sum_comp b.symm]
-  apply Fintype.sum_congr
-  intro i₂
-  congr
-  rw [Basis.reindex_apply v₁ b i₂]
-
-
-noncomputable def Laplace
-  (f : E → F)
-  : E → F := by
-  exact Laplace_wrt_basis (stdOrthonormalBasis ℝ E).toBasis (stdOrthonormalBasis ℝ E).orthonormal f
-
-
-theorem LaplaceIndep'''
-  [Fintype ι] [DecidableEq ι]
-  (v : Basis ι ℝ E)
-  (hv : Orthonormal ℝ v)
-  (f : E → F)
-  : (Laplace f) = (Laplace_wrt_basis v hv f) := by
-
-  unfold Laplace
-  apply LaplaceIndep'' (stdOrthonormalBasis ℝ E).toBasis (stdOrthonormalBasis ℝ E).orthonormal v hv f
-
-
-theorem Complex.Laplace'
-  (f : ℂ → F)
-  : (Laplace f) = fun z ↦ (iteratedFDeriv ℝ 2 f z) ![1, 1] + (iteratedFDeriv ℝ 2 f z) ![Complex.I, Complex.I] := by
-
-  rw [LaplaceIndep''' Complex.orthonormalBasisOneI.toBasis Complex.orthonormalBasisOneI.orthonormal f]
-  unfold Laplace_wrt_basis
-  simp

Nevanlinna/laplace.lean

@@ -219,6 +219,7 @@ theorem laplace_compCLMAt
     obtain ⟨u, hu₁, hu₂⟩ : ∃ u ∈ nhds x, ContDiffOn ℝ 2 f u := by
       apply ContDiffAt.contDiffOn h
       rfl
+      simp
     obtain ⟨v, hv₁, hv₂, hv₃⟩ := mem_nhds_iff.1 hu₁
     use v
     constructor

Nevanlinna/leftovers/diffOp.lean

@@ -69,7 +69,7 @@ noncomputable def Laplace
         simp
         apply continuous_finset_sum
         intro i _
-        exact ContinuousMultilinearMap.continuous_eval_const ![v i, v i]
+        exact ContinuousEvalConst.continuous_eval_const ![v i, v i]
     }
 
 
@@ -97,7 +97,7 @@ noncomputable def Gradient
         apply continuous_finset_sum
         intro i _
         apply Continuous.smul
-        exact ContinuousMultilinearMap.continuous_eval_const ![v i]
+        exact ContinuousEvalConst.continuous_eval_const ![v i]
         exact continuous_const
     }
 

Nevanlinna/leftovers/holomorphic_zero.lean

@@ -0,0 +1,171 @@
+import Init.Classical
+import Mathlib.Analysis.Analytic.Meromorphic
+import Mathlib.Topology.ContinuousOn
+import Mathlib.Analysis.Analytic.IsolatedZeros
+import Nevanlinna.leftovers.holomorphic
+import Nevanlinna.leftovers.analyticOnNhd_zeroSet
+
+
+noncomputable def zeroDivisor
+  (f : ℂ → ℂ) :
+  ℂ → ℕ := by
+  intro z
+  by_cases hf : AnalyticAt ℂ f z
+  · exact hf.order.toNat
+  · exact 0
+
+
+theorem analyticAtZeroDivisorSupport
+  {f : ℂ → ℂ}
+  {z : ℂ}
+  (h : z ∈ Function.support (zeroDivisor f)) :
+  AnalyticAt ℂ f z := by
+
+  by_contra h₁f
+  simp at h
+  dsimp [zeroDivisor] at h
+  simp [h₁f] at h
+
+
+theorem zeroDivisor_eq_ord_AtZeroDivisorSupport
+  {f : ℂ → ℂ}
+  {z : ℂ}
+  (h : z ∈ Function.support (zeroDivisor f)) :
+  zeroDivisor f z = (analyticAtZeroDivisorSupport h).order.toNat := by
+
+  unfold zeroDivisor
+  simp [analyticAtZeroDivisorSupport h]
+
+
+
+lemma toNatEqSelf_iff {n : ℕ∞} : n.toNat = n ↔ ∃ m : ℕ, m = n := by
+  constructor
+  · intro H₁
+    rw [← ENat.some_eq_coe, ← WithTop.ne_top_iff_exists]
+    by_contra H₂
+    rw [H₂] at H₁
+    simp at H₁
+  · intro H
+    obtain ⟨m, hm⟩ := H
+    rw [← hm]
+    simp
+
+
+lemma natural_if_toNatNeZero {n : ℕ∞} : n.toNat ≠ 0 → ∃ m : ℕ, m = n := by
+  rw [← ENat.some_eq_coe, ← WithTop.ne_top_iff_exists]
+  contrapose; simp; tauto
+
+
+theorem zeroDivisor_localDescription
+  {f : ℂ → ℂ}
+  {z₀ : ℂ}
+  (h : z₀ ∈ Function.support (zeroDivisor f)) :
+  ∃ (g : ℂ → ℂ), AnalyticAt ℂ g z₀ ∧ g z₀ ≠ 0 ∧ ∀ᶠ (z : ℂ) in nhds z₀, f z = (z - z₀) ^ (zeroDivisor f z₀) • g z := by
+
+  have A : zeroDivisor f ↑z₀ ≠ 0 := by exact h
+  let B := zeroDivisor_eq_ord_AtZeroDivisorSupport h
+  rw [B] at A
+  have C := natural_if_toNatNeZero A
+  obtain ⟨m, hm⟩ := C
+  have h₂m : m ≠ 0 := by
+    rw [← hm] at A
+    simp at A
+    assumption
+  rw [eq_comm] at hm
+  let E := AnalyticAt.order_eq_nat_iff (analyticAtZeroDivisorSupport h) m
+  let F := hm
+  rw [E] at F
+
+  have : m = zeroDivisor f z₀ := by
+    rw [B, hm]
+    simp
+  rwa [this] at F
+
+
+theorem zeroDivisor_zeroSet
+  {f : ℂ → ℂ}
+  {z₀ : ℂ}
+  (h : z₀ ∈ Function.support (zeroDivisor f)) :
+  f z₀ = 0 := by
+  obtain ⟨g, _, _, h₃⟩ := zeroDivisor_localDescription h
+  rw [Filter.Eventually.self_of_nhds h₃]
+  simp
+  left
+  exact h
+
+
+theorem zeroDivisor_support_iff
+  {f : ℂ → ℂ}
+  {z₀ : ℂ} :
+  z₀ ∈ Function.support (zeroDivisor f) ↔
+  f z₀ = 0 ∧
+  AnalyticAt ℂ f z₀ ∧
+  ∃ (g : ℂ → ℂ), AnalyticAt ℂ g z₀ ∧ g z₀ ≠ 0 ∧ ∀ᶠ (z : ℂ) in nhds z₀, f z = (z - z₀) ^ (zeroDivisor f z₀) • g z := by
+  constructor
+  · intro hz
+    constructor
+    · exact zeroDivisor_zeroSet hz
+    · constructor
+      · exact analyticAtZeroDivisorSupport hz
+      · exact zeroDivisor_localDescription hz
+  · intro ⟨h₁, h₂, h₃⟩
+    have : zeroDivisor f z₀ = (h₂.order).toNat := by
+      unfold zeroDivisor
+      simp [h₂]
+    simp [this]
+    simp [(h₂.order_eq_nat_iff (zeroDivisor f z₀)).2 h₃]
+    obtain ⟨g, h₁g, h₂g, h₃g⟩ := h₃
+    rw [Filter.Eventually.self_of_nhds h₃g] at h₁
+    simp [h₂g] at h₁
+    assumption
+
+
+theorem topOnPreconnected
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (hU : IsPreconnected U)
+  (h₁f : AnalyticOnNhd ℂ f U)
+  (h₂f : ∃ z ∈ U, f z ≠ 0) :
+  ∀ (hz : z ∈ U), (h₁f z hz).order ≠ ⊤ := by
+
+  by_contra H
+  push_neg at H
+  obtain ⟨z', hz'⟩ := H
+  rw [AnalyticAt.order_eq_top_iff] at hz'
+  rw [← AnalyticAt.frequently_zero_iff_eventually_zero (h₁f z z')] at hz'
+  have A := AnalyticOnNhd.eqOn_zero_of_preconnected_of_frequently_eq_zero h₁f hU z' hz'
+  tauto
+
+
+theorem supportZeroSet
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (hU : IsPreconnected U)
+  (h₁f : AnalyticOnNhd ℂ f U)
+  (h₂f : ∃ z ∈ U, f z ≠ 0) :
+  U ∩ Function.support (zeroDivisor f) = U ∩ f⁻¹' {0} := by
+
+  ext x
+  constructor
+  · intro hx
+    constructor
+    · exact hx.1
+    exact zeroDivisor_zeroSet hx.2
+  · simp
+    intro h₁x h₂x
+    constructor
+    · exact h₁x
+    · let A := zeroDivisor_support_iff (f := f) (z₀ := x)
+      simp at A
+      rw [A]
+      constructor
+      · exact h₂x
+      · constructor
+        · exact h₁f x h₁x
+        · have B := AnalyticAt.order_eq_nat_iff (h₁f x h₁x) (zeroDivisor f x)
+          simp at B
+          rw [← B]
+          dsimp [zeroDivisor]
+          simp [h₁f x h₁x]
+          refine Eq.symm (ENat.coe_toNat ?h.mpr.right.right.right.a)
+          exact topOnPreconnected hU h₁f h₂f h₁x

Nevanlinna/logpos.lean

@@ -0,0 +1,159 @@
+import Mathlib.Analysis.SpecialFunctions.Log.Basic
+
+open Real
+
+
+noncomputable def logpos : ℝ → ℝ := fun r ↦ max 0 (log r)
+
+notation "log⁺" => logpos
+
+
+theorem loglogpos {r : ℝ} : log r = log⁺ r - log⁺ r⁻¹ := by
+  unfold logpos
+  rw [log_inv]
+  by_cases h : 0 ≤ log r
+  · simp [h]
+  · simp at h
+    have : 0 ≤ -log r := Left.nonneg_neg_iff.2 (le_of_lt h)
+    simp [h, this]
+    exact neg_nonneg.mp this
+
+
+theorem logpos_norm {r : ℝ} : log⁺ r = 2⁻¹ * (log r + ‖log r‖) := by
+  by_cases hr : 0 ≤ log r
+  · rw [norm_of_nonneg hr]
+    have : logpos r = log r := by
+      unfold logpos
+      simp [hr]
+    rw [this]
+    ring
+  · rw [norm_of_nonpos (le_of_not_ge hr)]
+    have : logpos r = 0 := by
+      unfold logpos
+      simp
+      exact le_of_not_ge hr
+    rw [this]
+    ring
+
+
+theorem logpos_nonneg
+  {x : ℝ} :
+  0 ≤ log⁺ x := by
+  unfold logpos
+  simp
+
+
+theorem logpos_abs
+  {x : ℝ} :
+  log⁺ x = log⁺ |x| := by
+  unfold logpos
+  simp
+
+-- Warning: This should be fixed in Mathlib
+
+theorem log_pos_iff' (hx : 0 ≤ x) : 0 < log x ↔ 1 < x := by
+  by_cases h₁x : x = 0
+  · rw [h₁x]; simp
+  · exact log_pos_iff (lt_of_le_of_ne hx (Ne.symm h₁x))
+
+
+theorem Real.monotoneOn_logpos :
+  MonotoneOn logpos (Set.Ici 0) := by
+
+  intro x hx y hy hxy
+  unfold logpos
+  simp
+
+  by_cases h : log x ≤ 0
+  · tauto
+  · simp [h]
+    simp at h
+
+    have : log x ≤ log y := by
+      apply log_le_log
+      --
+      rw [log_pos_iff' hx] at h
+      have : (0 : ℝ) < 1 := by exact Real.zero_lt_one
+      exact lt_trans this h
+      assumption
+
+    constructor
+    · linarith
+    · linarith
+
+
+theorem logpos_add_le_add_logpos_add_log2₀
+  {a b : ℝ}
+  (h : |a| ≤ |b|) :
+  log⁺ (a + b) ≤ log⁺ a + log⁺ b + log 2 := by
+
+  nth_rw 1 [logpos_abs]
+  nth_rw 2 [logpos_abs]
+  nth_rw 3 [logpos_abs]
+
+  calc log⁺ |a + b|
+  _ ≤ log⁺ (|a| + |b|) := by
+    apply Real.monotoneOn_logpos
+    simp [abs_nonneg]; simp [abs_nonneg]
+    apply add_nonneg
+    simp [abs_nonneg]; simp [abs_nonneg]
+    exact abs_add_le a b
+  _ ≤ log⁺ (|b| + |b|) := by
+    apply Real.monotoneOn_logpos
+    simp [abs_nonneg]
+    apply add_nonneg
+    simp [abs_nonneg]; simp [abs_nonneg]
+    simp [h]
+    linarith
+  _ = log⁺ (2 * |b|) := by
+    congr; ring
+  _ ≤ log⁺ |b| + log 2 := by
+    unfold logpos; simp
+    constructor
+    · apply add_nonneg
+      simp
+      exact log_nonneg one_le_two
+    · by_cases hb: b = 0
+      · rw [hb]; simp
+        exact log_nonneg one_le_two
+      · rw [log_mul, log_abs, add_comm]
+        simp
+        exact Ne.symm (NeZero.ne' 2)
+        exact abs_ne_zero.mpr hb
+  _ ≤ log⁺ |a| + log⁺ |b| + log 2 := by
+    unfold logpos; simp
+
+
+theorem logpos_add_le_add_logpos_add_log2
+  {a b : ℝ} :
+  log⁺ (a + b) ≤ log⁺ a + log⁺ b + log 2 := by
+
+  by_cases h : |a| ≤ |b|
+  · exact logpos_add_le_add_logpos_add_log2₀ h
+  · rw [add_comm a b, add_comm (log⁺ a) (log⁺ b)]
+    apply logpos_add_le_add_logpos_add_log2₀
+    exact le_of_not_ge h
+
+theorem monoOn_logpos :
+  MonotoneOn log⁺ (Set.Ici 0) := by
+  intro x hx y hy hxy
+  by_cases h₁x : x = 0
+  · rw [h₁x]
+    unfold logpos
+    simp
+
+  simp at hx hy
+  unfold logpos
+  simp
+  by_cases h₂x : log x ≤ 0
+  · tauto
+  · simp [h₂x]
+    simp at h₂x
+    have : log x ≤ log y := by
+      apply log_le_log
+      exact lt_of_le_of_ne hx fun a => h₁x (id (Eq.symm a))
+      assumption
+    simp [this]
+    calc 0
+    _ ≤ log x := by exact le_of_lt h₂x
+    _ ≤ log y := this

Nevanlinna/mathlibAddOn.lean

@@ -1,6 +1,7 @@
 import Mathlib.Analysis.Analytic.Meromorphic
 import Mathlib.Analysis.Calculus.ContDiff.Basic
 import Mathlib.Analysis.Calculus.FDeriv.Add
+import Nevanlinna.analyticAt
 
 variable {𝕜 : Type*} [NontriviallyNormedField 𝕜]
 variable {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
@@ -36,18 +37,66 @@ theorem ContDiff.const_smul' {f : E → F} (c : R) (hf : ContDiff 𝕜 n f) :
   exact ContDiff.const_smul c hf
 
 
--- Mathlib.Analysis.Analytic.Meromorphic
 
-theorem meromorphicAt_congr
-  {𝕜 : Type u_1} [NontriviallyNormedField 𝕜]
-  {E : Type u_2} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
-  {f : 𝕜 → E} {g : 𝕜 → E} {x : 𝕜}
-  (h : f =ᶠ[nhdsWithin x {x}ᶜ] g) : MeromorphicAt f x ↔ MeromorphicAt g x :=
-  ⟨fun hf ↦ hf.congr h, fun hg ↦ hg.congr h.symm⟩
+open Topology Filter
 
-theorem meromorphicAt_congr'
-  {𝕜 : Type u_1} [NontriviallyNormedField 𝕜]
-  {E : Type u_2} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
-  {f : 𝕜 → E} {g : 𝕜 → E} {x : 𝕜}
-  (h : f =ᶠ[nhds x] g) : MeromorphicAt f x ↔ MeromorphicAt g x :=
-  meromorphicAt_congr (Filter.EventuallyEq.filter_mono h nhdsWithin_le_nhds)
+lemma Mnhds
+  {α : Type}
+  {f g : ℂ → α}
+  {z₀ : ℂ}
+  (h₁ : f =ᶠ[𝓝[≠] z₀] g)
+  (h₂ : f z₀ = g z₀) :
+  f =ᶠ[𝓝 z₀] g := by
+  apply eventually_nhds_iff.2
+  obtain ⟨t, h₁t, h₂t⟩ := eventually_nhds_iff.1 (eventually_nhdsWithin_iff.1 h₁)
+  use t
+  constructor
+  · intro y hy
+    by_cases h₂y : y ∈ ({z₀}ᶜ : Set ℂ)
+    · exact h₁t y hy h₂y
+    · simp at h₂y
+      rwa [h₂y]
+  · exact h₂t
+
+-- unclear where this should go
+
+lemma WithTopCoe
+  {n : WithTop ℕ} :
+  WithTop.map (Nat.cast : ℕ → ℤ) n = 0 → n = 0 := by
+  rcases n with h|h
+  · intro h
+    contradiction
+  · intro h₁
+    simp only [WithTop.map, Option.map] at h₁
+    have : (h : ℤ) = 0 := by
+      exact WithTop.coe_eq_zero.mp h₁
+    have : h = 0 := by
+      exact Int.ofNat_eq_zero.mp this
+    rw [this]
+    rfl
+
+lemma rwx
+  {a b : WithTop ℤ}
+  (ha : a ≠ ⊤)
+  (hb : b ≠ ⊤) :
+  a + b ≠ ⊤ := by
+  simp; tauto
+
+lemma untop_add
+  {a b : WithTop ℤ}
+  (ha : a ≠ ⊤)
+  (hb : b ≠ ⊤) :
+  (a + b).untop (rwx ha hb) = a.untop ha + (b.untop hb) := by
+  rw [WithTop.untop_eq_iff]
+  rw [WithTop.coe_add]
+  rw [WithTop.coe_untop]
+  rw [WithTop.coe_untop]
+
+lemma untop'_of_ne_top
+  {a : WithTop ℤ}
+  {d : ℤ}
+  (ha : a ≠ ⊤) :
+  WithTop.untop' d a = a := by
+  obtain ⟨b, hb⟩ := WithTop.ne_top_iff_exists.1 ha
+  rw [← hb]
+  simp

Nevanlinna/meromorphicAt.lean

@@ -7,9 +7,486 @@ open scoped Interval Topology
 open Real Filter MeasureTheory intervalIntegral
 
 
+theorem meromorphicAt_congr
+  {𝕜 : Type u_1} [NontriviallyNormedField 𝕜]
+  {E : Type u_2} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
+  {f : 𝕜 → E} {g : 𝕜 → E} {x : 𝕜}
+  (h : f =ᶠ[𝓝[≠] x] g) : MeromorphicAt f x ↔ MeromorphicAt g x :=
+  ⟨fun hf ↦ hf.congr h, fun hg ↦ hg.congr h.symm⟩
+
+
+theorem meromorphicAt_congr'
+  {𝕜 : Type u_1} [NontriviallyNormedField 𝕜]
+  {E : Type u_2} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
+  {f : 𝕜 → E} {g : 𝕜 → E} {x : 𝕜}
+  (h : f =ᶠ[nhds x] g) : MeromorphicAt f x ↔ MeromorphicAt g x :=
+  meromorphicAt_congr (Filter.EventuallyEq.filter_mono h nhdsWithin_le_nhds)
+
+
 theorem MeromorphicAt.eventually_eq_zero_or_eventually_ne_zero
   {f : ℂ → ℂ}
   {z₀ : ℂ}
   (hf : MeromorphicAt f z₀) :
-  (∀ᶠ (z : ℂ) in nhds z₀, f z = 0) ∨ ∀ᶠ (z : ℂ) in nhdsWithin z₀ {z₀}ᶜ, f z ≠ 0 := by
-  sorry
+  (∀ᶠ (z : ℂ) in nhdsWithin z₀ {z₀}ᶜ, f z = 0) ∨ ∀ᶠ (z : ℂ) in nhdsWithin z₀ {z₀}ᶜ, f z ≠ 0 := by
+
+  obtain ⟨n, h⟩ := hf
+  let A := h.eventually_eq_zero_or_eventually_ne_zero
+
+  rw [eventually_nhdsWithin_iff]
+  rw [eventually_nhds_iff]
+  rcases A with h₁|h₂
+  · rw [eventually_nhds_iff] at h₁
+    obtain ⟨N, h₁N, h₂N, h₃N⟩ := h₁
+    left
+    use N
+    constructor
+    · intro y h₁y h₂y
+      let A := h₁N y h₁y
+      simp at A
+      rcases A with h₃|h₄
+      · let B := h₃.1
+        simp at h₂y
+        let C := sub_eq_zero.1 B
+        tauto
+      · assumption
+    · constructor
+      · exact h₂N
+      · exact h₃N
+  · right
+    rw [eventually_nhdsWithin_iff]
+    rw [eventually_nhds_iff]
+    rw [eventually_nhdsWithin_iff] at h₂
+    rw [eventually_nhds_iff] at h₂
+    obtain ⟨N, h₁N, h₂N, h₃N⟩ := h₂
+    use N
+    constructor
+    · intro y h₁y h₂y
+      by_contra h
+      let A := h₁N y h₁y h₂y
+      rw [h] at A
+      simp at A
+    · constructor
+      · exact h₂N
+      · exact h₃N
+
+
+theorem MeromorphicAt.order_congr
+  {f₁ f₂ : ℂ → ℂ}
+  {z₀ : ℂ}
+  (hf₁ : MeromorphicAt f₁ z₀)
+  (h : f₁ =ᶠ[𝓝[≠] z₀] f₂):
+  hf₁.order = (hf₁.congr h).order := by
+  by_cases hord : hf₁.order = ⊤
+  · rw [hord, eq_comm]
+    rw [hf₁.order_eq_top_iff] at hord
+    rw [(hf₁.congr h).order_eq_top_iff]
+    exact EventuallyEq.rw hord (fun x => Eq (f₂ x)) (_root_.id (EventuallyEq.symm h))
+  · obtain ⟨n, hn : hf₁.order = n⟩ := Option.ne_none_iff_exists'.mp hord
+    obtain ⟨g, h₁g, h₂g, h₃g⟩ := (hf₁.order_eq_int_iff n).1 hn
+    rw [hn, eq_comm, (hf₁.congr h).order_eq_int_iff]
+    use g
+    constructor
+    · assumption
+    · constructor
+      · assumption
+      · exact EventuallyEq.rw h₃g (fun x => Eq (f₂ x)) (_root_.id (EventuallyEq.symm h))
+
+
+theorem MeromorphicAt.order_mul
+  {f₁ f₂ : ℂ → ℂ}
+  {z₀ : ℂ}
+  (hf₁ : MeromorphicAt f₁ z₀)
+  (hf₂ : MeromorphicAt f₂ z₀) :
+  (hf₁.mul hf₂).order = hf₁.order + hf₂.order := by
+  by_cases h₂f₁ : hf₁.order = ⊤
+  · simp [h₂f₁]
+    rw [hf₁.order_eq_top_iff, eventually_nhdsWithin_iff, eventually_nhds_iff] at h₂f₁
+    rw [(hf₁.mul hf₂).order_eq_top_iff, eventually_nhdsWithin_iff, eventually_nhds_iff]
+    obtain ⟨t, h₁t, h₂t, h₃t⟩ := h₂f₁
+    use t
+    constructor
+    · intro y h₁y h₂y
+      simp; left
+      rw [h₁t y h₁y h₂y]
+    · exact ⟨h₂t, h₃t⟩
+  · by_cases h₂f₂ : hf₂.order = ⊤
+    · simp [h₂f₂]
+      rw [hf₂.order_eq_top_iff, eventually_nhdsWithin_iff, eventually_nhds_iff] at h₂f₂
+      rw [(hf₁.mul hf₂).order_eq_top_iff, eventually_nhdsWithin_iff, eventually_nhds_iff]
+      obtain ⟨t, h₁t, h₂t, h₃t⟩ := h₂f₂
+      use t
+      constructor
+      · intro y h₁y h₂y
+        simp; right
+        rw [h₁t y h₁y h₂y]
+      · exact ⟨h₂t, h₃t⟩
+    · have h₃f₁ := Eq.symm (WithTop.coe_untop hf₁.order h₂f₁)
+      have h₃f₂ := Eq.symm (WithTop.coe_untop hf₂.order h₂f₂)
+      obtain ⟨g₁, h₁g₁, h₂g₁, h₃g₁⟩ := (hf₁.order_eq_int_iff (hf₁.order.untop h₂f₁)).1 h₃f₁
+      obtain ⟨g₂, h₁g₂, h₂g₂, h₃g₂⟩ := (hf₂.order_eq_int_iff (hf₂.order.untop h₂f₂)).1 h₃f₂
+      rw [h₃f₁, h₃f₂, ← WithTop.coe_add]
+      rw [MeromorphicAt.order_eq_int_iff]
+      use g₁ * g₂
+      constructor
+      · exact AnalyticAt.mul h₁g₁ h₁g₂
+      · constructor
+        · simp; tauto
+        · obtain ⟨t₁, h₁t₁, h₂t₁, h₃t₁⟩ := eventually_nhds_iff.1 (eventually_nhdsWithin_iff.1 h₃g₁)
+          obtain ⟨t₂, h₁t₂, h₂t₂, h₃t₂⟩ := eventually_nhds_iff.1 (eventually_nhdsWithin_iff.1 h₃g₂)
+          rw [eventually_nhdsWithin_iff, eventually_nhds_iff]
+          use t₁ ∩ t₂
+          constructor
+          · intro y h₁y h₂y
+            simp
+            rw [h₁t₁ y h₁y.1 h₂y, h₁t₂ y h₁y.2 h₂y]
+            simp
+            rw [zpow_add' (by left; exact sub_ne_zero_of_ne h₂y)]
+            group
+          · constructor
+            · exact IsOpen.inter h₂t₁ h₂t₂
+            · exact Set.mem_inter h₃t₁ h₃t₂
+
+
+theorem MeromorphicAt.order_neg_zero_iff
+  {f : ℂ → ℂ}
+  {z₀ : ℂ}
+  (hf : MeromorphicAt f z₀) :
+  hf.order ≠ ⊤ ↔ ∃ (g : ℂ → ℂ), AnalyticAt ℂ g z₀ ∧ g z₀ ≠ 0 ∧ ∀ᶠ (z : ℂ) in nhdsWithin z₀ {z₀}ᶜ, f z = (z - z₀) ^ (hf.order.untop' 0) • g z := by
+
+  constructor
+  · intro h
+    exact (hf.order_eq_int_iff (hf.order.untop' 0)).1 (Eq.symm (untop'_of_ne_top h))
+  · rw [← hf.order_eq_int_iff]
+    intro h
+    exact Option.ne_none_iff_exists'.mpr ⟨hf.order.untop' 0, h⟩
+
+
+theorem MeromorphicAt.order_inv
+  {f : ℂ → ℂ}
+  {z₀ : ℂ}
+  (hf : MeromorphicAt f z₀) :
+  hf.order = -hf.inv.order := by
+
+  by_cases h₂f : hf.order = ⊤
+  · simp [h₂f]
+    have : hf.inv.order = ⊤ := by
+      rw [hf.inv.order_eq_top_iff]
+      rw [eventually_nhdsWithin_iff]
+      rw [eventually_nhds_iff]
+
+      rw [hf.order_eq_top_iff] at h₂f
+      rw [eventually_nhdsWithin_iff] at h₂f
+      rw [eventually_nhds_iff] at h₂f
+      obtain ⟨t, h₁t, h₂t, h₃t⟩ := h₂f
+      use t
+      constructor
+      · intro y h₁y h₂y
+        simp
+        rw [h₁t y h₁y h₂y]
+      · exact ⟨h₂t, h₃t⟩
+    rw [this]
+    simp
+
+  · have : hf.order = hf.order.untop' 0 := by
+      simp [h₂f, untop'_of_ne_top]
+    rw [this]
+    rw [eq_comm]
+    rw [neg_eq_iff_eq_neg]
+    apply (hf.inv.order_eq_int_iff (-hf.order.untop' 0)).2
+    rw [hf.order_eq_int_iff] at this
+    obtain ⟨g, h₁g, h₂g, h₃g⟩ := this
+    use g⁻¹
+    constructor
+    · exact AnalyticAt.inv h₁g h₂g
+    · constructor
+      · simp [h₂g]
+      · rw [eventually_nhdsWithin_iff]
+        rw [eventually_nhds_iff]
+        rw [eventually_nhdsWithin_iff] at h₃g
+        rw [eventually_nhds_iff] at h₃g
+        obtain ⟨t, h₁t, h₂t, h₃t⟩ := h₃g
+        use t
+        constructor
+        · intro y h₁y h₂y
+          simp
+          let A := h₁t y h₁y h₂y
+          rw [A]
+          simp
+          rw [mul_comm]
+        · exact ⟨h₂t, h₃t⟩
+
+
+theorem AnalyticAt.meromorphicAt_order_nonneg
+  {f : ℂ → ℂ}
+  {z₀ : ℂ}
+  (hf : AnalyticAt ℂ f z₀) :
+  0 ≤ hf.meromorphicAt.order := by
+  rw [hf.meromorphicAt_order]
+  rw [(by rfl : (0 : WithTop ℤ) = WithTop.map Nat.cast (0 : ℕ∞))]
+  erw [WithTop.map_le_iff]
+  simp; simp
+
+
+theorem MeromorphicAt.order_add
+  {f₁ f₂ : ℂ → ℂ}
+  {z₀ : ℂ}
+  (hf₁ : MeromorphicAt f₁ z₀)
+  (hf₂ : MeromorphicAt f₂ z₀) :
+  min hf₁.order hf₂.order ≤ (hf₁.add hf₂).order := by
+
+  -- Handle the trivial cases where one of the orders equals ⊤
+  by_cases h₂f₁: hf₁.order = ⊤
+  · rw [h₂f₁]; simp
+    rw [hf₁.order_eq_top_iff] at h₂f₁
+    have h : f₁ + f₂ =ᶠ[𝓝[≠] z₀] f₂ := by
+      -- Optimize this, here an elsewhere
+      rw [eventuallyEq_nhdsWithin_iff, eventually_iff_exists_mem]
+      rw [eventually_nhdsWithin_iff, eventually_iff_exists_mem] at h₂f₁
+      obtain ⟨v, hv⟩ := h₂f₁
+      use v; simp; trivial
+    rw [(hf₁.add hf₂).order_congr h]
+  by_cases h₂f₂: hf₂.order = ⊤
+  · rw [h₂f₂]; simp
+    rw [hf₂.order_eq_top_iff] at h₂f₂
+    have h : f₁ + f₂ =ᶠ[𝓝[≠] z₀] f₁ := by
+      rw [eventuallyEq_nhdsWithin_iff, eventually_iff_exists_mem]
+      rw [eventually_nhdsWithin_iff, eventually_iff_exists_mem] at h₂f₂
+      obtain ⟨v, hv⟩ := h₂f₂
+      use v; simp; trivial
+    rw [(hf₁.add hf₂).order_congr h]
+
+  obtain ⟨g₁, h₁g₁, h₂g₁, h₃g₁⟩ := hf₁.order_neg_zero_iff.1 h₂f₁
+  obtain ⟨g₂, h₁g₂, h₂g₂, h₃g₂⟩ := hf₂.order_neg_zero_iff.1 h₂f₂
+
+  let n₁ := WithTop.untop' 0 hf₁.order
+  let n₂ := WithTop.untop' 0 hf₂.order
+  let n := min n₁ n₂
+  have h₁n₁ : 0 ≤ n₁ - n := by
+    rw [sub_nonneg]
+    exact Int.min_le_left n₁ n₂
+  have h₁n₂ : 0 ≤ n₂ - n := by
+    rw [sub_nonneg]
+    exact Int.min_le_right n₁ n₂
+
+  let g := (fun z ↦ (z - z₀) ^ (n₁ - n)) * g₁ +  (fun z ↦ (z - z₀) ^ (n₂ - n)) * g₂
+  have h₁g : AnalyticAt ℂ g z₀ := by
+    apply AnalyticAt.add
+    apply AnalyticAt.mul
+    apply AnalyticAt.zpow_nonneg _ h₁n₁
+    apply AnalyticAt.sub
+    apply analyticAt_id
+    apply analyticAt_const
+    exact h₁g₁
+    apply AnalyticAt.mul
+    apply AnalyticAt.zpow_nonneg _ h₁n₂
+    apply AnalyticAt.sub
+    apply analyticAt_id
+    apply analyticAt_const
+    exact h₁g₂
+  have h₂g : 0 ≤ h₁g.meromorphicAt.order := h₁g.meromorphicAt_order_nonneg
+
+  have : f₁ + f₂ =ᶠ[𝓝[≠] z₀] (fun z ↦ (z - z₀) ^ n) * g := by
+    rw [eventuallyEq_nhdsWithin_iff, eventually_nhds_iff]
+    obtain ⟨t, ht⟩ := eventually_nhds_iff.1 (eventually_nhdsWithin_iff.1 (h₃g₁.and h₃g₂))
+    use t
+    simp [ht]
+    intro y h₁y h₂y
+    rw [(ht.1 y h₁y h₂y).1, (ht.1 y h₁y h₂y).2]
+    unfold g; simp; rw [mul_add]
+    repeat rw [←mul_assoc, ← zpow_add' (by left; exact (sub_ne_zero_of_ne h₂y))]
+    simp
+
+  rw [(hf₁.add hf₂).order_congr this]
+
+  have t₀ : MeromorphicAt (fun z ↦ (z - z₀) ^ n) z₀ := by
+    apply MeromorphicAt.zpow
+    apply MeromorphicAt.sub
+    apply MeromorphicAt.id
+    apply MeromorphicAt.const
+  rw [t₀.order_mul h₁g.meromorphicAt]
+  have t₁ : t₀.order = n := by
+    rw [t₀.order_eq_int_iff]
+    use 1
+    constructor
+    · apply analyticAt_const
+    · simp
+  rw [t₁]
+  unfold n n₁ n₂
+  have : hf₁.order ⊓ hf₂.order = (WithTop.untop' 0 hf₁.order ⊓ WithTop.untop' 0 hf₂.order) := by
+    rw [←untop'_of_ne_top (d := 0) h₂f₁, ←untop'_of_ne_top (d := 0) h₂f₂]
+    simp
+  rw [this]
+  exact le_add_of_nonneg_right h₂g
+
+
+theorem MeromorphicAt.order_add_of_ne_orders
+  {f₁ f₂ : ℂ → ℂ}
+  {z₀ : ℂ}
+  (hf₁ : MeromorphicAt f₁ z₀)
+  (hf₂ : MeromorphicAt f₂ z₀)
+  (hf₁₂ : hf₁.order ≠ hf₂.order) :
+  min hf₁.order hf₂.order = (hf₁.add hf₂).order := by
+
+  -- Handle the trivial cases where one of the orders equals ⊤
+  by_cases h₂f₁: hf₁.order = ⊤
+  · rw [h₂f₁]; simp
+    rw [hf₁.order_eq_top_iff] at h₂f₁
+    have h : f₁ + f₂ =ᶠ[𝓝[≠] z₀] f₂ := by
+      -- Optimize this, here an elsewhere
+      rw [eventuallyEq_nhdsWithin_iff, eventually_iff_exists_mem]
+      rw [eventually_nhdsWithin_iff, eventually_iff_exists_mem] at h₂f₁
+      obtain ⟨v, hv⟩ := h₂f₁
+      use v; simp; trivial
+    rw [(hf₁.add hf₂).order_congr h]
+  by_cases h₂f₂: hf₂.order = ⊤
+  · rw [h₂f₂]; simp
+    rw [hf₂.order_eq_top_iff] at h₂f₂
+    have h : f₁ + f₂ =ᶠ[𝓝[≠] z₀] f₁ := by
+      rw [eventuallyEq_nhdsWithin_iff, eventually_iff_exists_mem]
+      rw [eventually_nhdsWithin_iff, eventually_iff_exists_mem] at h₂f₂
+      obtain ⟨v, hv⟩ := h₂f₂
+      use v; simp; trivial
+    rw [(hf₁.add hf₂).order_congr h]
+
+  obtain ⟨g₁, h₁g₁, h₂g₁, h₃g₁⟩ := hf₁.order_neg_zero_iff.1 h₂f₁
+  obtain ⟨g₂, h₁g₂, h₂g₂, h₃g₂⟩ := hf₂.order_neg_zero_iff.1 h₂f₂
+
+  let n₁ := WithTop.untop' 0 hf₁.order
+  let n₂ := WithTop.untop' 0 hf₂.order
+  have hn₁₂ : n₁ ≠ n₂ := by
+    unfold n₁ n₂
+    let A := WithTop.untop'_eq_untop'_iff (d := 0) (x := hf₁.order) (y := hf₂.order)
+    let B := A.not
+    simp
+    rw [B]
+    push_neg
+    constructor
+    · assumption
+    · tauto
+
+  let n := min n₁ n₂
+  have h₁n₁ : 0 ≤ n₁ - n := by
+    rw [sub_nonneg]
+    exact Int.min_le_left n₁ n₂
+  have h₁n₂ : 0 ≤ n₂ - n := by
+    rw [sub_nonneg]
+    exact Int.min_le_right n₁ n₂
+
+  let g := (fun z ↦ (z - z₀) ^ (n₁ - n)) * g₁ +  (fun z ↦ (z - z₀) ^ (n₂ - n)) * g₂
+  have h₁g : AnalyticAt ℂ g z₀ := by
+    apply AnalyticAt.add
+    apply AnalyticAt.mul
+    apply AnalyticAt.zpow_nonneg _ h₁n₁
+    apply AnalyticAt.sub
+    apply analyticAt_id
+    apply analyticAt_const
+    exact h₁g₁
+    apply AnalyticAt.mul
+    apply AnalyticAt.zpow_nonneg _ h₁n₂
+    apply AnalyticAt.sub
+    apply analyticAt_id
+    apply analyticAt_const
+    exact h₁g₂
+  have h₂g : 0 ≤ h₁g.meromorphicAt.order := h₁g.meromorphicAt_order_nonneg
+  have h₂'g : g z₀ ≠ 0 := by
+    unfold g
+    simp
+    have : n = n₁ ∨ n = n₂ := by
+      unfold n
+      simp
+      by_cases h : n₁ ≤ n₂
+      · left; assumption
+      · right
+        simp at h
+        exact le_of_lt h
+    rcases this with h|h
+    · rw [h]
+      have : n₂ - n₁ ≠ 0 := by
+        rw [sub_ne_zero, ne_comm]
+        apply hn₁₂
+      have : (0 : ℂ) ^ (n₂ - n₁) = 0 := by
+        rwa [zpow_eq_zero_iff]
+      simp [this]
+      exact h₂g₁
+    · rw [h]
+      have : n₁ - n₂ ≠ 0 := by
+        rw [sub_ne_zero]
+        apply hn₁₂
+      have : (0 : ℂ) ^ (n₁ - n₂) = 0 := by
+        rwa [zpow_eq_zero_iff]
+      simp [this]
+      exact h₂g₂
+  have h₃g : h₁g.meromorphicAt.order = 0 := by
+    let A := h₁g.meromorphicAt_order
+    let B := h₁g.order_eq_zero_iff.2 h₂'g
+    rw [B] at A
+    simpa
+
+  have : f₁ + f₂ =ᶠ[𝓝[≠] z₀] (fun z ↦ (z - z₀) ^ n) * g := by
+    rw [eventuallyEq_nhdsWithin_iff, eventually_nhds_iff]
+    obtain ⟨t, ht⟩ := eventually_nhds_iff.1 (eventually_nhdsWithin_iff.1 (h₃g₁.and h₃g₂))
+    use t
+    simp [ht]
+    intro y h₁y h₂y
+    rw [(ht.1 y h₁y h₂y).1, (ht.1 y h₁y h₂y).2]
+    unfold g; simp; rw [mul_add]
+    repeat rw [←mul_assoc, ← zpow_add' (by left; exact (sub_ne_zero_of_ne h₂y))]
+    simp
+
+  rw [(hf₁.add hf₂).order_congr this]
+
+  have t₀ : MeromorphicAt (fun z ↦ (z - z₀) ^ n) z₀ := by
+    apply MeromorphicAt.zpow
+    apply MeromorphicAt.sub
+    apply MeromorphicAt.id
+    apply MeromorphicAt.const
+  rw [t₀.order_mul h₁g.meromorphicAt]
+  have t₁ : t₀.order = n := by
+    rw [t₀.order_eq_int_iff]
+    use 1
+    constructor
+    · apply analyticAt_const
+    · simp
+  rw [t₁]
+  unfold n n₁ n₂
+  have : hf₁.order ⊓ hf₂.order = (WithTop.untop' 0 hf₁.order ⊓ WithTop.untop' 0 hf₂.order) := by
+    rw [←untop'_of_ne_top (d := 0) h₂f₁, ←untop'_of_ne_top (d := 0) h₂f₂]
+    simp
+  rw [this, h₃g]
+  simp
+
+-- Might want to think about adding an analytic function instead of a constant
+theorem MeromorphicAt.order_add_const
+  --have {z : ℂ} : 0 < (hf z trivial).order → (hf z trivial).order = ((hf.add (MeromorphicOn.const a)) z trivial).order:= by
+  {f : ℂ → ℂ}
+  {z a : ℂ}
+  (hf : MeromorphicAt f z) :
+  hf.order < 0 → hf.order = (hf.add (MeromorphicAt.const a z)).order := by
+  intro h
+
+  by_cases ha: a = 0
+  · -- might want theorem MeromorphicAt.order_const
+    have : (MeromorphicAt.const a z).order = ⊤ := by
+      rw [MeromorphicAt.order_eq_top_iff]
+      rw [ha]
+      simp
+    rw [←hf.order_add_of_ne_orders (MeromorphicAt.const a z)]
+    rw [this]
+    simp
+    rw [this]
+    exact LT.lt.ne_top h
+  · have : (MeromorphicAt.const a z).order = (0 : ℤ) := by
+      rw [MeromorphicAt.order_eq_int_iff]
+      use fun _ ↦ a
+      constructor
+      · exact analyticAt_const
+      · simpa
+    rw [←hf.order_add_of_ne_orders (MeromorphicAt.const a z)]
+    rw [this]
+    simp
+    exact le_of_lt h
+    rw [this]
+    exact ne_of_lt h
+
+
+-- might want theorem MeromorphicAt.order_zpow

Nevanlinna/meromorphicOn.lean

@@ -0,0 +1,185 @@
+import Mathlib.Analysis.Analytic.Meromorphic
+import Nevanlinna.analyticAt
+import Nevanlinna.divisor
+import Nevanlinna.meromorphicAt
+import Nevanlinna.stronglyMeromorphicOn
+import Nevanlinna.mathlibAddOn
+
+open scoped Interval Topology
+open Real Filter MeasureTheory intervalIntegral
+
+theorem MeromorphicOn.open_of_order_eq_top
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (h₁f : MeromorphicOn f U) :
+  IsOpen { u : U | (h₁f u.1 u.2).order = ⊤ } := by
+
+  apply isOpen_iff_forall_mem_open.mpr
+  intro z hz
+  simp at hz
+
+  have h₁z := hz
+  rw [MeromorphicAt.order_eq_top_iff] at hz
+  rw [eventually_nhdsWithin_iff] at hz
+  rw [eventually_nhds_iff] at hz
+  obtain ⟨t', h₁t', h₂t', h₃t'⟩ := hz
+  let t : Set U := Subtype.val ⁻¹' t'
+  use t
+  constructor
+  · intro w hw
+    simp
+    by_cases h₁w : w = z
+    · rwa [h₁w]
+    · --
+      rw [MeromorphicAt.order_eq_top_iff]
+      rw [eventually_nhdsWithin_iff]
+      rw [eventually_nhds_iff]
+      use t' \ {z.1}
+      constructor
+      · intro y h₁y h₂y
+        apply h₁t'
+        exact Set.mem_of_mem_diff h₁y
+        exact Set.mem_of_mem_inter_right h₁y
+      · constructor
+        · apply IsOpen.sdiff h₂t'
+          exact isClosed_singleton
+        · rw [Set.mem_diff]
+          constructor
+          · exact hw
+          · simp
+            exact Subtype.coe_ne_coe.mpr h₁w
+
+  · constructor
+    · exact isOpen_induced h₂t'
+    · exact h₃t'
+
+
+theorem MeromorphicOn.open_of_order_neq_top
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (h₁f : MeromorphicOn f U) :
+  IsOpen { u : U | (h₁f u.1 u.2).order ≠ ⊤ } := by
+
+  apply isOpen_iff_forall_mem_open.mpr
+  intro z hz
+  simp at hz
+
+  let A := (h₁f z.1 z.2).eventually_eq_zero_or_eventually_ne_zero
+  rcases A with h|h
+  · rw [← (h₁f z.1 z.2).order_eq_top_iff] at h
+    tauto
+  · let A := (h₁f z.1 z.2).eventually_analyticAt
+    let B := Filter.Eventually.and h A
+    rw [eventually_nhdsWithin_iff] at B
+    rw [eventually_nhds_iff] at B
+    obtain ⟨t', h₁t', h₂t', h₃t'⟩ := B
+    let t : Set U := Subtype.val ⁻¹' t'
+    use t
+    constructor
+    · intro w hw
+      simp
+      by_cases h₁w : w = z
+      · rwa [h₁w]
+      · let B := h₁t' w hw
+        simp at B
+        have : (w : ℂ) ≠ (z : ℂ) := by exact Subtype.coe_ne_coe.mpr h₁w
+        let C := B this
+        let D := C.2.order_eq_zero_iff.2 C.1
+        rw [C.2.meromorphicAt_order, D]
+        simp
+    · constructor
+      · exact isOpen_induced h₂t'
+      · exact h₃t'
+
+
+theorem MeromorphicOn.clopen_of_order_eq_top
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (h₁f : MeromorphicOn f U) :
+  IsClopen { u : U | (h₁f u.1 u.2).order = ⊤ } := by
+
+  constructor
+  · rw [← isOpen_compl_iff]
+    exact open_of_order_neq_top h₁f
+  · exact open_of_order_eq_top h₁f
+
+
+theorem MeromorphicOn.order_ne_top'
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (h₁f : MeromorphicOn f U)
+  (hU : IsConnected U) :
+  (∃ u : U, (h₁f u u.2).order ≠ ⊤) ↔ (∀ u : U, (h₁f u u.2).order ≠ ⊤) := by
+
+  constructor
+  · intro h₂f
+    let A := h₁f.clopen_of_order_eq_top
+    have : PreconnectedSpace U := by
+      apply isPreconnected_iff_preconnectedSpace.mp
+      exact IsConnected.isPreconnected hU
+    rw [isClopen_iff] at A
+    rcases A with h|h
+    · intro u
+      have : u ∉ (∅ : Set U) := by exact fun a => a
+      rw [← h] at this
+      simp at this
+      tauto
+    · obtain ⟨u, hU⟩ := h₂f
+      have A : u ∈ Set.univ := by trivial
+      rw [← h] at A
+      simp at A
+      tauto
+  · intro h₂f
+    let A := hU.nonempty
+    obtain ⟨v, hv⟩ := A
+    use ⟨v, hv⟩
+    exact h₂f ⟨v, hv⟩
+
+
+theorem StronglyMeromorphicOn.order_ne_top
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (h₁f : StronglyMeromorphicOn f U)
+  (hU : IsConnected U)
+  (h₂f : ∃ u : U, f u ≠ 0) :
+  ∀ u : U, (h₁f u u.2).meromorphicAt.order ≠ ⊤ := by
+
+  rw [← h₁f.meromorphicOn.order_ne_top' hU]
+  obtain ⟨u, hu⟩ := h₂f
+  use u
+  rw [← (h₁f u u.2).order_eq_zero_iff] at hu
+  rw [hu]
+  simp
+
+
+theorem MeromorphicOn.nonvanish_of_order_ne_top
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (h₁f : MeromorphicOn f U)
+  (h₂f : ∃ u : U, (h₁f u u.2).order ≠ ⊤)
+  (h₁U : IsConnected U)
+  (h₂U : interior U ≠ ∅) :
+  ∃ u ∈ U, f u ≠ 0 := by
+
+  by_contra hCon
+  push_neg at hCon
+
+  have : ∃ u : U, (h₁f u u.2).order = ⊤ := by
+    obtain ⟨v, h₁v⟩ := Set.nonempty_iff_ne_empty'.2 h₂U
+    have h₂v : v ∈ U := by apply interior_subset h₁v
+    use ⟨v, h₂v⟩
+    rw [MeromorphicAt.order_eq_top_iff]
+    rw [eventually_nhdsWithin_iff]
+    rw [eventually_nhds_iff]
+    use interior U
+    constructor
+    · intro y h₁y h₂y
+      exact hCon y (interior_subset h₁y)
+    · simp [h₁v]
+
+  let A := h₁f.order_ne_top' h₁U
+  rw [← not_iff_not] at A
+  push_neg at A
+  have B := A.2 this
+  obtain ⟨u, hu⟩ := h₂f
+  tauto

Nevanlinna/meromorphicOn_divisor.lean

@@ -1,57 +1,14 @@
 import Mathlib.Analysis.Analytic.Meromorphic
 import Nevanlinna.analyticAt
 import Nevanlinna.divisor
+import Nevanlinna.meromorphicAt
+import Nevanlinna.meromorphicOn
+import Nevanlinna.stronglyMeromorphicOn
 
 
 open scoped Interval Topology
 open Real Filter MeasureTheory intervalIntegral
 
-theorem MeromorphicAt.eventually_eq_zero_or_eventually_ne_zero
-  {f : ℂ → ℂ}
-  {z₀ : ℂ}
-  (hf : MeromorphicAt f z₀) :
-  (∀ᶠ (z : ℂ) in nhdsWithin z₀ {z₀}ᶜ, f z = 0) ∨ ∀ᶠ (z : ℂ) in nhdsWithin z₀ {z₀}ᶜ, f z ≠ 0 := by
-
-  obtain ⟨n, h⟩ := hf
-  let A := h.eventually_eq_zero_or_eventually_ne_zero
-
-  rw [eventually_nhdsWithin_iff]
-  rw [eventually_nhds_iff]
-  rcases A with h₁|h₂
-  · rw [eventually_nhds_iff] at h₁
-    obtain ⟨N, h₁N, h₂N, h₃N⟩ := h₁
-    left
-    use N
-    constructor
-    · intro y h₁y h₂y
-      let A := h₁N y h₁y
-      simp at A
-      rcases A with h₃|h₄
-      · let B := h₃.1
-        simp at h₂y
-        let C := sub_eq_zero.1 B
-        tauto
-      · assumption
-    · constructor
-      · exact h₂N
-      · exact h₃N
-  · right
-    rw [eventually_nhdsWithin_iff]
-    rw [eventually_nhds_iff]
-    rw [eventually_nhdsWithin_iff] at h₂
-    rw [eventually_nhds_iff] at h₂
-    obtain ⟨N, h₁N, h₂N, h₃N⟩ := h₂
-    use N
-    constructor
-    · intro y h₁y h₂y
-      by_contra h
-      let A := h₁N y h₁y h₂y
-      rw [h] at A
-      simp at A
-    · constructor
-      · exact h₂N
-      · exact h₃N
-
 
 noncomputable def MeromorphicOn.divisor
   {f : ℂ → ℂ}
@@ -119,3 +76,319 @@ noncomputable def MeromorphicOn.divisor
           simp
         · simp [h₃y]
       · tauto
+
+
+theorem MeromorphicOn.divisor_def₁
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  {z : ℂ}
+  (hf : MeromorphicOn f U)
+  (hz : z ∈ U) :
+  hf.divisor z = ((hf z hz).order.untop' 0 : ℤ) := by
+  unfold MeromorphicOn.divisor
+  simp [hz]
+
+
+theorem MeromorphicOn.divisor_def₂
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  {z : ℂ}
+  (hf : MeromorphicOn f U)
+  (hz : z ∈ U)
+  (h₂f : (hf z hz).order ≠ ⊤) :
+  hf.divisor z = (hf z hz).order.untop h₂f := by
+  unfold MeromorphicOn.divisor
+  simp [hz]
+  rw [WithTop.untop'_eq_iff]
+  left
+  exact Eq.symm (WithTop.coe_untop (hf z hz).order h₂f)
+
+
+theorem MeromorphicOn.divisor_mul₀
+  {f₁ f₂ : ℂ → ℂ}
+  {U : Set ℂ}
+  {z : ℂ}
+  (hz : z ∈ U)
+  (h₁f₁ : MeromorphicOn f₁ U)
+  (h₂f₁ : (h₁f₁ z hz).order ≠ ⊤)
+  (h₁f₂ : MeromorphicOn f₂ U)
+  (h₂f₂ : (h₁f₂ z hz).order ≠ ⊤) :
+  (h₁f₁.mul h₁f₂).divisor.toFun z = h₁f₁.divisor.toFun z + h₁f₂.divisor.toFun z := by
+  by_cases h₁z : z ∈ U
+  · rw [MeromorphicOn.divisor_def₂ h₁f₁ hz h₂f₁]
+    rw [MeromorphicOn.divisor_def₂ h₁f₂ hz h₂f₂]
+    have B : ((h₁f₁.mul h₁f₂) z hz).order ≠ ⊤ := by
+      rw [MeromorphicAt.order_mul (h₁f₁ z hz) (h₁f₂ z hz)]
+      simp; tauto
+    rw [MeromorphicOn.divisor_def₂ (h₁f₁.mul h₁f₂) hz B]
+    simp_rw [MeromorphicAt.order_mul (h₁f₁ z hz) (h₁f₂ z hz)]
+    rw [untop_add]
+  · unfold MeromorphicOn.divisor
+    simp [h₁z]
+
+
+theorem MeromorphicOn.divisor_mul
+  {f₁ f₂ : ℂ → ℂ}
+  {U : Set ℂ}
+  (h₁f₁ : MeromorphicOn f₁ U)
+  (h₂f₁ : ∀ z, (hz : z ∈ U) → (h₁f₁ z hz).order ≠ ⊤)
+  (h₁f₂ : MeromorphicOn f₂ U)
+  (h₂f₂ : ∀ z, (hz : z ∈ U) → (h₁f₂ z hz).order ≠ ⊤) :
+  (h₁f₁.mul h₁f₂).divisor.toFun = h₁f₁.divisor.toFun + h₁f₂.divisor.toFun := by
+  funext z
+  by_cases hz : z ∈ U
+  · rw [MeromorphicOn.divisor_mul₀ hz h₁f₁ (h₂f₁ z hz) h₁f₂ (h₂f₂ z hz)]
+    simp
+  · simp
+    rw [Function.nmem_support.mp (fun a => hz (h₁f₁.divisor.supportInU a))]
+    rw [Function.nmem_support.mp (fun a => hz (h₁f₂.divisor.supportInU a))]
+    rw [Function.nmem_support.mp (fun a => hz ((h₁f₁.mul h₁f₂).divisor.supportInU a))]
+    simp
+
+
+theorem MeromorphicOn.divisor_inv
+  {f: ℂ → ℂ}
+  {U : Set ℂ}
+  (h₁f : MeromorphicOn f U) :
+  h₁f.inv.divisor.toFun = -h₁f.divisor.toFun := by
+  funext z
+
+  by_cases hz : z ∈ U
+  · rw [MeromorphicOn.divisor_def₁]
+    simp
+    rw [MeromorphicOn.divisor_def₁]
+    rw [MeromorphicAt.order_inv]
+    simp
+    by_cases h₂f : (h₁f z hz).order = ⊤
+    · simp [h₂f]
+    · let A := untop'_of_ne_top (d := 0) h₂f
+      rw [← A]
+      exact rfl
+    repeat exact hz
+  · unfold MeromorphicOn.divisor
+    simp [hz]
+
+
+theorem MeromorphicOn.divisor_add_const₁
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  {z : ℂ}
+  (hf : MeromorphicOn f U)
+  (a : ℂ) :
+  0 ≤ hf.divisor z → 0 ≤ (hf.add (MeromorphicOn.const a)).divisor z := by
+  intro h
+
+  unfold MeromorphicOn.divisor
+
+  -- Trivial case: z ∉ U
+  by_cases hz : z ∉ U
+  · simp [hz]
+
+  -- Non-trivial case: z ∈ U
+  simp at hz; simp [hz]
+
+  by_cases h₁f : (hf z hz).order = ⊤
+  · have : f + (fun z ↦ a) =ᶠ[𝓝[≠] z] (fun z ↦ a) := by
+      rw [MeromorphicAt.order_eq_top_iff] at h₁f
+      rw [eventually_nhdsWithin_iff] at h₁f
+      rw [eventually_nhds_iff] at h₁f
+      obtain ⟨t, ht⟩ := h₁f
+      rw [eventuallyEq_nhdsWithin_iff]
+      rw [eventually_nhds_iff]
+      use t
+      simp [ht]
+      tauto
+    rw [((hf z hz).add (MeromorphicAt.const a z)).order_congr this]
+
+    by_cases ha: (MeromorphicAt.const a z).order = ⊤
+    · simp [ha]
+    · rw [WithTop.le_untop'_iff]
+      apply AnalyticAt.meromorphicAt_order_nonneg
+      exact analyticAt_const
+      tauto
+
+  · rw [WithTop.le_untop'_iff]
+    let A := (hf z hz).order_add (MeromorphicAt.const a z)
+    have : 0 ≤ min (hf z hz).order (MeromorphicAt.const a z).order := by
+      apply le_min
+      --
+      unfold MeromorphicOn.divisor at h
+      simp [hz] at h
+      let V := untop'_of_ne_top (d := 0) h₁f
+      rw [← V]
+      simp [h]
+      --
+      apply AnalyticAt.meromorphicAt_order_nonneg
+      exact analyticAt_const
+    exact le_trans this A
+    tauto
+
+
+theorem MeromorphicOn.divisor_add_const₂
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  {z : ℂ}
+  (hf : MeromorphicOn f U)
+  (a : ℂ) :
+  hf.divisor z < 0 → (hf.add (MeromorphicOn.const a)).divisor z < 0 := by
+  intro h
+
+  by_cases hz : z ∉ U
+  · have : hf.divisor z = 0 := by
+      unfold MeromorphicOn.divisor
+      simp [hz]
+    rw [this] at h
+    tauto
+
+  simp at hz
+  unfold MeromorphicOn.divisor
+  simp [hz]
+  unfold MeromorphicOn.divisor at h
+  simp [hz] at h
+
+  have : (hf z hz).order = (((hf.add (MeromorphicOn.const a))) z hz).order := by
+    have t₀ : (hf z hz).order < (0 : ℤ) := by
+        by_contra hCon
+        simp only [not_lt] at hCon
+        rw [←WithTop.le_untop'_iff (b := 0)] at hCon
+        exact Lean.Omega.Int.le_lt_asymm hCon h
+        tauto
+    rw [← MeromorphicAt.order_add_of_ne_orders (hf z hz) (MeromorphicAt.const a z)]
+    simp
+
+    by_cases ha: (MeromorphicAt.const a z).order = ⊤
+    · simp [ha]
+    · calc (hf z hz).order
+      _ ≤ 0 := by exact le_of_lt t₀
+      _ ≤ (MeromorphicAt.const a z).order := by
+        apply AnalyticAt.meromorphicAt_order_nonneg
+        exact analyticAt_const
+
+    apply ne_of_lt
+    calc (hf z hz).order
+      _ < 0 := by exact t₀
+      _ ≤ (MeromorphicAt.const a z).order := by
+        apply AnalyticAt.meromorphicAt_order_nonneg
+        exact analyticAt_const
+  rwa [this] at h
+
+
+theorem MeromorphicOn.divisor_add_const₃
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  {z : ℂ}
+  (hf : MeromorphicOn f U)
+  (a : ℂ) :
+  hf.divisor z < 0 → (hf.add (MeromorphicOn.const a)).divisor z = hf.divisor z := by
+  intro h
+
+  by_cases hz : z ∉ U
+  · have : hf.divisor z = 0 := by
+      unfold MeromorphicOn.divisor
+      simp [hz]
+    rw [this] at h
+    tauto
+
+  simp at hz
+  unfold MeromorphicOn.divisor
+  simp [hz]
+  unfold MeromorphicOn.divisor at h
+  simp [hz] at h
+
+  have : (hf z hz).order = (((hf.add (MeromorphicOn.const a))) z hz).order := by
+    have t₀ : (hf z hz).order < (0 : ℤ) := by
+        by_contra hCon
+        simp only [not_lt] at hCon
+        rw [←WithTop.le_untop'_iff (b := 0)] at hCon
+        exact Lean.Omega.Int.le_lt_asymm hCon h
+        tauto
+    rw [← MeromorphicAt.order_add_of_ne_orders (hf z hz) (MeromorphicAt.const a z)]
+    simp
+
+    by_cases ha: (MeromorphicAt.const a z).order = ⊤
+    · simp [ha]
+    · calc (hf z hz).order
+      _ ≤ 0 := by exact le_of_lt t₀
+      _ ≤ (MeromorphicAt.const a z).order := by
+        apply AnalyticAt.meromorphicAt_order_nonneg
+        exact analyticAt_const
+
+    apply ne_of_lt
+    calc (hf z hz).order
+      _ < 0 := by exact t₀
+      _ ≤ (MeromorphicAt.const a z).order := by
+        apply AnalyticAt.meromorphicAt_order_nonneg
+        exact analyticAt_const
+  rw [this]
+
+
+theorem MeromorphicOn.divisor_of_makeStronglyMeromorphicOn
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (hf : MeromorphicOn f U) :
+  hf.divisor = (stronglyMeromorphicOn_of_makeStronglyMeromorphicOn hf).meromorphicOn.divisor := by
+  unfold MeromorphicOn.divisor
+  simp
+  funext z
+  by_cases hz : z ∈ U
+  · simp [hz]
+    congr 1
+    apply MeromorphicAt.order_congr
+    exact EventuallyEq.symm (makeStronglyMeromorphicOn_changeDiscrete hf hz)
+  · simp [hz]
+
+
+
+-- STRONGLY MEROMORPHIC THINGS
+
+/- Strongly MeromorphicOn of non-negative order is analytic -/
+theorem StronglyMeromorphicOn.analyticOnNhd
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (h₁f : StronglyMeromorphicOn f U)
+  (h₂f : ∀ x, (hx : x ∈ U) → 0 ≤ h₁f.meromorphicOn.divisor x) :
+  AnalyticOnNhd ℂ f U := by
+
+  apply StronglyMeromorphicOn.analytic
+  intro z hz
+  let A := h₂f z hz
+  unfold MeromorphicOn.divisor at A
+  simp [hz] at A
+  by_cases h : (h₁f z hz).meromorphicAt.order = ⊤
+  · rw [h]
+    simp
+  · rw [WithTop.le_untop'_iff] at A
+    tauto
+    tauto
+  assumption
+
+
+theorem StronglyMeromorphicOn.support_divisor
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (h₁f : StronglyMeromorphicOn f U)
+  (h₂f : ∃ u : U, f u ≠ 0)
+  (hU : IsConnected U) :
+  U ∩ f⁻¹' {0} = (Function.support h₁f.meromorphicOn.divisor) := by
+
+  ext u
+  constructor
+  · intro hu
+    unfold MeromorphicOn.divisor
+    simp [h₁f.order_ne_top hU h₂f ⟨u, hu.1⟩]
+    use hu.1
+    rw [(h₁f u hu.1).order_eq_zero_iff]
+    simp
+    exact hu.2
+  · intro hu
+    simp at hu
+    let A := h₁f.meromorphicOn.divisor.supportInU hu
+    constructor
+    · exact h₁f.meromorphicOn.divisor.supportInU hu
+    · simp
+      let B := (h₁f u A).order_eq_zero_iff.not
+      simp at B
+      rw [← B]
+      unfold MeromorphicOn.divisor at hu
+      simp [A] at hu
+      exact hu.1

Nevanlinna/meromorphicOn_integrability.lean

@@ -0,0 +1,180 @@
+import Mathlib.Analysis.Analytic.Meromorphic
+import Mathlib.MeasureTheory.Integral.CircleIntegral
+import Mathlib.MeasureTheory.Integral.IntervalIntegral
+import Nevanlinna.analyticAt
+import Nevanlinna.divisor
+import Nevanlinna.intervalIntegrability
+import Nevanlinna.logpos
+import Nevanlinna.meromorphicAt
+import Nevanlinna.meromorphicOn_divisor
+import Nevanlinna.specialFunctions_CircleIntegral_affine
+import Nevanlinna.stronglyMeromorphicOn
+import Nevanlinna.stronglyMeromorphicOn_eliminate
+import Nevanlinna.mathlibAddOn
+
+open scoped Interval Topology
+open Real Filter MeasureTheory intervalIntegral
+
+
+theorem MeromorphicOn.integrable_log_abs_f₀
+  {f : ℂ → ℂ}
+  {r : ℝ}
+  -- WARNING: Not optimal. This needs to go
+  (hr : 0 < r)
+  -- WARNING: Not optimal. It suffices to be meromorphic on the Sphere
+  (h₁f : MeromorphicOn f (Metric.closedBall (0 : ℂ) r)) :
+  IntervalIntegrable (fun z ↦ log ‖f (circleMap 0 r z)‖) MeasureTheory.volume 0 (2 * π) := by
+
+  by_cases h₂f : ∃ u : (Metric.closedBall (0 : ℂ) r), (h₁f u u.2).order ≠ ⊤
+  · have h₁U : IsCompact (Metric.closedBall (0 : ℂ) r) := isCompact_closedBall 0 r
+
+    have h₂U : IsConnected (Metric.closedBall (0 : ℂ) r) := by
+      constructor
+      · exact Metric.nonempty_closedBall.mpr (le_of_lt hr)
+      · exact (convex_closedBall (0 : ℂ) r).isPreconnected
+
+    -- This is where we use 'ball' instead of sphere. However, better
+    -- results should make this assumption unnecessary.
+    have h₃U : interior (Metric.closedBall (0 : ℂ) r) ≠ ∅ := by
+      rw [interior_closedBall, ← Set.nonempty_iff_ne_empty]
+      use 0; simp [hr];
+      repeat exact Ne.symm (ne_of_lt hr)
+
+    have h₃f : Set.Finite (Function.support h₁f.divisor) := by
+      exact Divisor.finiteSupport h₁U h₁f.divisor
+
+    obtain ⟨g, h₁g, h₂g, h₃g⟩ := MeromorphicOn.decompose_log h₁U h₂U h₃U h₁f h₂f
+    have : (fun z ↦ log ‖f (circleMap 0 r z)‖) = (fun z ↦ log ‖f z‖) ∘ (circleMap 0 r) := by
+      rfl
+    rw [this]
+    have : Metric.sphere (0 : ℂ) |r| ⊆ Metric.closedBall (0 : ℂ) r := by
+      rw [abs_of_pos hr]
+      apply Metric.sphere_subset_closedBall
+
+    rw [integrability_congr_changeDiscrete this h₃g]
+
+    apply IntervalIntegrable.add
+    --
+    apply Continuous.intervalIntegrable
+    apply continuous_iff_continuousAt.2
+    intro x
+    have : (fun x => log ‖g (circleMap 0 r x)‖) = log ∘ Complex.abs ∘ g ∘ (fun x ↦ circleMap 0 r x) :=
+      rfl
+    rw [this]
+    apply ContinuousAt.comp
+    apply Real.continuousAt_log
+    · simp
+      have : (circleMap 0 r x) ∈ (Metric.closedBall (0 : ℂ) r) := by
+        apply circleMap_mem_closedBall
+        exact le_of_lt hr
+      exact h₂g ⟨(circleMap 0 r x), this⟩
+    apply ContinuousAt.comp
+    · apply Continuous.continuousAt Complex.continuous_abs
+    apply ContinuousAt.comp
+    · have : (circleMap 0 r x) ∈ (Metric.closedBall (0 : ℂ) r) := by
+        apply circleMap_mem_closedBall (0 : ℂ) (le_of_lt hr) x
+      apply (h₁g (circleMap 0 r x) this).continuousAt
+    apply Continuous.continuousAt (continuous_circleMap 0 r)
+    --
+    have h {x : ℝ} : (Function.support fun s => (h₁f.divisor s) * log ‖circleMap 0 r x - s‖) ⊆ h₃f.toFinset := by
+      intro x; simp; tauto
+    simp_rw [finsum_eq_sum_of_support_subset _ h]
+    have : (fun x => ∑ s ∈ h₃f.toFinset, (h₁f.divisor s) * log ‖circleMap 0 r x - s‖) = (∑ s ∈ h₃f.toFinset, fun x => (h₁f.divisor s) * log ‖circleMap 0 r x - s‖) := by
+      ext x; simp
+    rw [this]
+    apply IntervalIntegrable.sum h₃f.toFinset
+    intro s hs
+    apply IntervalIntegrable.const_mul
+
+    apply intervalIntegrable_logAbs_circleMap_sub_const
+    exact Ne.symm (ne_of_lt hr)
+
+  · push_neg at h₂f
+
+    let F := h₁f.makeStronglyMeromorphicOn
+    have : (fun z => log ‖f z‖) =ᶠ[Filter.codiscreteWithin (Metric.closedBall 0 r)] (fun z => log ‖F z‖) := by
+      -- WANT: apply Filter.eventuallyEq.congr
+      let A := (makeStronglyMeromorphicOn_changeDiscrete'' h₁f)
+      obtain ⟨s, h₁s, h₂s⟩ := eventuallyEq_iff_exists_mem.1 A
+      rw [eventuallyEq_iff_exists_mem]
+      use s
+      constructor
+      · exact h₁s
+      · intro x hx
+        simp_rw [h₂s hx]
+    have hU : Metric.sphere (0 : ℂ) |r| ⊆ Metric.closedBall 0 r := by
+      rw [abs_of_pos hr]
+      exact Metric.sphere_subset_closedBall
+    have t₀ : (fun z => log ‖f (circleMap 0 r z)‖) =  (fun z => log ‖f z‖) ∘ circleMap 0 r := by
+      rfl
+    rw [t₀]
+    clear t₀
+    rw [integrability_congr_changeDiscrete hU this]
+
+    have : ∀ x ∈ Metric.closedBall 0 r, F x = 0 := by
+      intro x hx
+      let A := h₂f ⟨x, hx⟩
+      rw [← makeStronglyMeromorphicOn_changeOrder h₁f hx] at A
+      let B := ((stronglyMeromorphicOn_of_makeStronglyMeromorphicOn h₁f) x hx).order_eq_zero_iff.not.1
+      simp [A] at B
+      assumption
+    have : (fun z => log ‖F z‖) ∘ circleMap 0 r = 0 := by
+      funext x
+      simp
+      left
+      apply this
+      simp [abs_of_pos hr]
+    simp_rw [this]
+    apply intervalIntegral.intervalIntegrable_const
+
+
+theorem MeromorphicOn.integrable_log_abs_f
+  {f : ℂ → ℂ}
+  {r : ℝ}
+  -- WARNING: Not optimal. It suffices to be meromorphic on the Sphere
+  (h₁f : MeromorphicOn f (Metric.closedBall (0 : ℂ) |r|)) :
+  IntervalIntegrable (fun z ↦ log ‖f (circleMap 0 r z)‖) MeasureTheory.volume 0 (2 * π) := by
+
+  by_cases h₁r : r = 0
+  · rw [h₁r]
+    simp
+  · by_cases h₂r : 0 < r
+    · have : |r| = r := by
+        exact abs_of_pos h₂r
+      rw [this] at h₁f
+      exact MeromorphicOn.integrable_log_abs_f₀ h₂r h₁f
+    · have t₀ : 0 < -r := by
+        have hr_neg : r < 0 := by
+          apply lt_of_le_of_ne
+          exact le_of_not_lt h₂r
+          exact h₁r
+        linarith
+      have : |r| = -r := by
+        apply abs_of_neg
+        exact Left.neg_pos_iff.mp t₀
+      rw [this] at h₁f
+      let A := MeromorphicOn.integrable_log_abs_f₀ t₀ h₁f
+
+      let B := integrability_congr_negRadius (f := fun z => log ‖f z‖) (r := -r)
+      let C := B A
+      simp at C
+      simpa
+
+
+theorem MeromorphicOn.integrable_logpos_abs_f
+  {f : ℂ → ℂ}
+  {r : ℝ}
+  -- WARNING: Not optimal. It suffices to be meromorphic on the Sphere
+  (h₁f : MeromorphicOn f (Metric.closedBall (0 : ℂ) |r|)) :
+  IntervalIntegrable (fun z ↦ logpos ‖f (circleMap 0 r z)‖) MeasureTheory.volume 0 (2 * π) := by
+
+  simp_rw [logpos_norm]
+  simp_rw [mul_add]
+
+  apply IntervalIntegrable.add
+  apply IntervalIntegrable.const_mul
+  exact MeromorphicOn.integrable_log_abs_f h₁f
+
+  apply IntervalIntegrable.const_mul
+  apply IntervalIntegrable.norm
+  exact MeromorphicOn.integrable_log_abs_f h₁f

Nevanlinna/partialDeriv.lean

@@ -202,14 +202,14 @@ theorem partialDeriv_compContLin
     left
     intro w
     left
-    rw [fderiv.comp w (ContinuousLinearMap.differentiableAt l) (h w)]
+    rw [fderiv_comp w (ContinuousLinearMap.differentiableAt l) (h w)]
   simp
   rfl
 
 
 theorem partialDeriv_compContLinAt {f : E → F} {l : F →L[𝕜] G} {v : E} {x : E} (h : DifferentiableAt 𝕜 f x) : (partialDeriv 𝕜 v (l ∘ f)) x = (l ∘ partialDeriv 𝕜 v f) x:= by
   unfold partialDeriv
-  rw [fderiv.comp x (ContinuousLinearMap.differentiableAt l) h]
+  rw [fderiv_comp x (ContinuousLinearMap.differentiableAt l) h]
   simp
 
 
@@ -281,7 +281,11 @@ lemma partialDeriv_fderiv {f : E → F} (hf : ContDiff 𝕜 2 f) (z a b : E) :
   unfold partialDeriv
   rw [fderiv_clm_apply]
   · simp
-  · exact (contDiff_succ_iff_fderiv.1 hf).2.differentiable le_rfl z
+  · apply Differentiable.differentiableAt
+    rw [← one_add_one_eq_two] at hf
+    rw [contDiff_succ_iff_fderiv] at hf
+    apply hf.2.2.differentiable
+    simp
   · simp
 
 
@@ -298,7 +302,9 @@ lemma partialDeriv_fderivOn
   · simp
   · convert DifferentiableOn.differentiableAt _ (IsOpen.mem_nhds hs hz)
     apply ContDiffOn.differentiableOn _ (Preorder.le_refl 1)
-    exact ((contDiffOn_succ_iff_fderiv_of_isOpen hs).1 hf).2
+    rw [← one_add_one_eq_two] at hf
+    rw [contDiffOn_succ_iff_fderiv_of_isOpen hs] at hf
+    exact hf.2.2
   · simp
 
 
@@ -407,7 +413,8 @@ theorem partialDeriv_comm
     let f'' := (fderiv ℝ f' z)
     have h₁ : HasFDerivAt f' f'' z := by
       apply DifferentiableAt.hasFDerivAt
-      apply (contDiff_succ_iff_fderiv.1 h).right.differentiable (Preorder.le_refl 1)
+      rw [← one_add_one_eq_two] at h
+      apply (contDiff_succ_iff_fderiv.1 h).2.2.differentiable (Preorder.le_refl 1)
 
     apply second_derivative_symmetric h₀ h₁ v₁ v₂
 
@@ -442,7 +449,8 @@ theorem partialDeriv_commOn
       apply DifferentiableAt.hasFDerivAt
       apply DifferentiableOn.differentiableAt _ (IsOpen.mem_nhds hs hz)
       apply ContDiffOn.differentiableOn _ (Preorder.le_refl 1)
-      exact ((contDiffOn_succ_iff_fderiv_of_isOpen hs).1 h).2
+      rw [← one_add_one_eq_two] at h
+      exact ((contDiffOn_succ_iff_fderiv_of_isOpen hs).1 h).2.2
 
     have h₀' : ∀ᶠ (y : E) in nhds z, HasFDerivAt f (f' y) y := by
       apply eventually_nhds_iff.mpr
@@ -463,7 +471,9 @@ theorem partialDeriv_commAt
   (h : ContDiffAt ℝ 2 f z) :
   ∀ v₁ v₂ : E, partialDeriv ℝ v₁ (partialDeriv ℝ v₂ f) z = partialDeriv ℝ v₂ (partialDeriv ℝ v₁ f) z := by
 
-  obtain ⟨u, hu₁, hu₂⟩ := h.contDiffOn le_rfl
+  let A := h.contDiffOn le_rfl
+  simp at A
+  obtain ⟨u, hu₁, hu₂⟩ := A
   obtain ⟨v, hv₁, hv₂, hv₃⟩ := mem_nhds_iff.1 hu₁
 
   intro v₁ v₂

Nevanlinna/specialFunctions_CircleIntegral_affine.lean

@@ -3,6 +3,7 @@ import Mathlib.MeasureTheory.Integral.CircleIntegral
 import Nevanlinna.specialFunctions_Integral_log_sin
 import Nevanlinna.harmonicAt_examples
 import Nevanlinna.harmonicAt_meanValue
+import Nevanlinna.intervalIntegrability
 import Nevanlinna.periodic_integrability
 
 open scoped Interval Topology
@@ -44,7 +45,7 @@ lemma l₂ {x : ℝ} : ‖(circleMap 0 1 x) - a‖ = ‖1 - (circleMap 0 1 (-x))
 
 lemma int'₀
   {a : ℂ}
-  (ha : a ∈ Metric.ball 0 1) :
+  (ha : ‖a‖ ≠ 1) :
   IntervalIntegrable (fun x ↦ log ‖circleMap 0 1 x - a‖) volume 0 (2 * π) := by
   apply Continuous.intervalIntegrable
   apply Continuous.log
@@ -94,9 +95,9 @@ lemma int₀
 
   let ρ := ‖a‖⁻¹
   have hρ : 1 < ρ := by
-    apply one_lt_inv_iff.mpr
+    apply one_lt_inv_iff₀.mpr
     constructor
-    · exact norm_pos_iff'.mpr h₁a
+    · exact norm_pos_iff.mpr h₁a
     · exact mem_ball_zero_iff.mp ha
 
   let F := fun z ↦ log ‖1 - z * a‖
@@ -114,7 +115,7 @@ lemma int₀
       _ < ρ * ‖a‖ := by
         apply (mul_lt_mul_right _).2
         exact mem_ball_zero_iff.mp hx
-        exact norm_pos_iff'.mpr h₁a
+        exact norm_pos_iff.mpr h₁a
       _ = 1 := by
         dsimp [ρ]
         apply inv_mul_cancel₀
@@ -130,6 +131,7 @@ lemma int₀
 
 -- Integral of log ‖circleMap 0 1 x - 1‖
 
+-- integral
 lemma int₁₁ : ∫ (x : ℝ) in (0)..π, log (4 * sin x ^ 2) = 0 := by
 
   have t₁ {x : ℝ} : x ∈ Set.Ioo 0 π → log (4 * sin x ^ 2) = log 4 + 2 * log (sin x) := by
@@ -248,6 +250,7 @@ lemma int₁ :
 
 -- Integral of log ‖circleMap 0 1 x - a‖, for ‖a‖ = 1
 
+-- integrability
 lemma int'₂
   {a : ℂ}
   (ha : ‖a‖ = 1) :
@@ -310,7 +313,7 @@ lemma int'₂
   simp_rw [this] at A
   exact A
 
-
+-- integral
 lemma int₂
   {a : ℂ}
   (ha : ‖a‖ = 1) :
@@ -370,7 +373,7 @@ lemma int₂
   simp_rw [this]
   exact int₁
 
-
+-- integral
 lemma int₃
   {a : ℂ}
   (ha : a ∈ Metric.closedBall 0 1) :
@@ -382,3 +385,149 @@ lemma int₃
     simp at h₁a
     simp
     linarith
+
+-- integral
+lemma int₄
+  {a : ℂ}
+  {R : ℝ}
+  (hR : 0 < R)
+  (ha : a ∈ Metric.closedBall 0 R) :
+  ∫ x in (0)..(2 * π), log ‖circleMap 0 R x - a‖ = (2 * π) * log R := by
+
+  have h₁a : a / R ∈ Metric.closedBall 0 1 := by
+    simp
+    simp at ha
+    rw [div_le_comm₀]
+    simp
+    have : R = |R| := by
+      exact Eq.symm (abs_of_pos hR)
+    rwa [this] at ha
+    rwa [abs_of_pos hR]
+    simp
+
+  have t₀ {x : ℝ} : circleMap 0 R x = R * circleMap 0 1 x := by
+    unfold circleMap
+    simp
+
+  have {x : ℝ} : circleMap 0 R x - a = R * (circleMap 0 1 x - (a / R)) := by
+    rw [t₀, mul_sub, mul_div_cancel₀]
+    rw [ne_eq, Complex.ofReal_eq_zero]
+    exact Ne.symm (ne_of_lt hR)
+
+  have {x : ℝ} : circleMap 0 R x ≠ a → log ‖circleMap 0 R x - a‖ = log R + log ‖circleMap 0 1 x - (a / R)‖ := by
+    intro hx
+    rw [this]
+    rw [norm_mul]
+    rw [log_mul]
+    congr
+    --
+    simp
+    exact le_of_lt hR
+    --
+    simp
+    exact Ne.symm (ne_of_lt hR)
+    --
+    simp
+    rw [t₀] at hx
+    by_contra hCon
+    rw [hCon] at hx
+    simp at hx
+    rw [mul_div_cancel₀] at hx
+    tauto
+    simp
+    exact Ne.symm (ne_of_lt hR)
+
+  have : ∫ x in (0)..(2 * π), log ‖circleMap 0 R x - a‖ = ∫ x in (0)..(2 * π), log R + log ‖circleMap 0 1 x - (a / R)‖ := by
+    rw [intervalIntegral.integral_congr_ae]
+    rw [MeasureTheory.ae_iff]
+    apply Set.Countable.measure_zero
+    let A := (circleMap 0 R)⁻¹' { a }
+    have s₀ : {a_1 | ¬(a_1 ∈ Ι 0 (2 * π) → log ‖circleMap 0 R a_1 - a‖ = log R + log ‖circleMap 0 1 a_1 - a / ↑R‖)} ⊆ A := by
+      intro x
+      contrapose
+      intro hx
+      unfold A at hx
+      simp at hx
+      simp
+      intro h₂x
+      let B := this hx
+      simp at B
+      rw [B]
+    have s₁ : A.Countable := by
+      apply Set.Countable.preimage_circleMap
+      exact Set.countable_singleton a
+      exact Ne.symm (ne_of_lt hR)
+    exact Set.Countable.mono s₀ s₁
+
+  rw [this]
+  rw [intervalIntegral.integral_add]
+  rw [int₃]
+  rw [intervalIntegral.integral_const]
+  simp
+  --
+  exact h₁a
+  --
+  apply intervalIntegral.intervalIntegrable_const
+  --
+  by_cases h₂a : ‖a / R‖ = 1
+  · exact int'₂ h₂a
+  · exact int'₀ h₂a
+
+
+lemma intervalIntegrable_logAbs_circleMap_sub_const
+  {a : ℂ}
+  {r : ℝ}
+  (hr : r ≠ 0) :
+  IntervalIntegrable (fun x ↦ log ‖circleMap 0 r x - a‖) volume 0 (2 * π) := by
+
+  have {z : ℂ} : z ≠ a → log ‖z - a‖ = log ‖r⁻¹ * z - r⁻¹ * a‖ + log ‖r‖ := by
+    intro hz
+    rw [← mul_sub, norm_mul]
+    rw [log_mul (by simp [hr]) (by simp [hz])]
+    simp
+
+  have : (fun z ↦ log ‖z - a‖) =ᶠ[Filter.codiscreteWithin ⊤] (fun z ↦ log ‖r⁻¹ * z - r⁻¹ * a‖ + log ‖r‖) := by
+    apply eventuallyEq_iff_exists_mem.mpr
+    use {a}ᶜ
+    constructor
+    · simp_rw [mem_codiscreteWithin, Filter.disjoint_principal_right]
+      simp
+      intro y
+      by_cases hy : y = a
+      · rw [← hy]
+        exact self_mem_nhdsWithin
+      · refine mem_nhdsWithin.mpr ?_
+        simp
+        use {a}ᶜ
+        constructor
+        · exact isOpen_compl_singleton
+        · constructor
+          · tauto
+          · tauto
+    · intro x hx
+      simp at hx
+      simp only [Complex.norm_eq_abs]
+      repeat rw [← Complex.norm_eq_abs]
+      apply this hx
+
+  have hU : Metric.sphere (0 : ℂ) |r| ⊆ ⊤ := by
+    exact fun ⦃a⦄ a => trivial
+  let A := integrability_congr_changeDiscrete hU this
+
+  have : (fun z => log ‖z - a‖) ∘ circleMap 0 r = (fun z => log ‖circleMap 0 r z - a‖) := by
+    exact rfl
+  rw [this] at A
+  have : (fun z => log ‖r⁻¹ * z - r⁻¹ * a‖ + log ‖r‖) ∘ circleMap 0 r = (fun z => log ‖r⁻¹ * circleMap 0 r z - r⁻¹ * a‖ + log ‖r‖) := by
+    exact rfl
+  rw [this] at A
+  rw [A]
+
+  apply IntervalIntegrable.add _ intervalIntegrable_const
+  have {x : ℝ} : r⁻¹ * circleMap 0 r x = circleMap 0 1 x := by
+    unfold circleMap
+    simp [hr]
+  simp_rw [this]
+
+  by_cases ha : ‖r⁻¹ * a‖ = 1
+  · exact int'₂ ha
+  · apply int'₀ ha

Nevanlinna/specialFunctions_Integral_log_sin.lean

@@ -105,6 +105,8 @@ lemma intervalIntegrable_log_sin₁ : IntervalIntegrable (log ∘ sin) volume 0
 
   have int_log : IntervalIntegrable (fun x ↦ ‖log x‖) volume 0 1 := by
     apply IntervalIntegrable.norm
+    -- Extract lemma here: log is integrable on [0, 1], and in fact on any
+    -- interval [a, b]
     rw [← neg_neg log]
     apply IntervalIntegrable.neg
     apply intervalIntegrable_deriv_of_nonneg (g := fun x ↦ -(x * log x - x))

Nevanlinna/stronglyMeromorphicAt.lean

@@ -1,6 +1,8 @@
 import Mathlib.Analysis.Analytic.Meromorphic
+import Mathlib.Algebra.Order.AddGroupWithTop
 import Nevanlinna.analyticAt
 import Nevanlinna.mathlibAddOn
+import Nevanlinna.meromorphicAt
 
 
 open Topology
@@ -13,6 +15,52 @@ def StronglyMeromorphicAt
   (∀ᶠ (z : ℂ) in nhds z₀, f z = 0) ∨ (∃ (n : ℤ), ∃ g : ℂ → ℂ, (AnalyticAt ℂ g z₀) ∧ (g z₀ ≠ 0) ∧ (∀ᶠ (z : ℂ) in nhds z₀, f z = (z - z₀) ^ n • g z))
 
 
+lemma stronglyMeromorphicAt_of_mul_analytic'
+  {f g : ℂ → ℂ}
+  {z₀ : ℂ}
+  (h₁g : AnalyticAt ℂ g z₀)
+  (h₂g : g z₀ ≠ 0) :
+  StronglyMeromorphicAt f z₀ → StronglyMeromorphicAt (f * g) z₀ := by
+
+  intro hf
+  --unfold StronglyMeromorphicAt at hf
+  rcases hf with h₁f|h₁f
+  · left
+    rw [eventually_nhds_iff] at h₁f
+    obtain ⟨t, ht⟩ := h₁f
+    rw [eventually_nhds_iff]
+    use t
+    constructor
+    · intro y hy
+      simp
+      left
+      exact ht.1 y hy
+    · exact ht.2
+  · right
+    obtain ⟨n, g_f, h₁g_f, h₂g_f, h₃g_f⟩ := h₁f
+    use n
+    use g * g_f
+    constructor
+    · apply AnalyticAt.mul
+      exact h₁g
+      exact h₁g_f
+    · constructor
+      · simp
+        exact ⟨h₂g, h₂g_f⟩
+      · rw [eventually_nhds_iff] at h₃g_f
+        obtain ⟨t, ht⟩ := h₃g_f
+        rw [eventually_nhds_iff]
+        use t
+        constructor
+        · intro y hy
+          simp
+          rw [ht.1]
+          simp
+          ring
+          exact hy
+        · exact ht.2
+
+
 /- Strongly MeromorphicAt is Meromorphic -/
 theorem StronglyMeromorphicAt.meromorphicAt
   {f : ℂ → ℂ}
@@ -121,6 +169,112 @@ theorem stronglyMeromorphicAt_congr
         · apply Filter.EventuallyEq.trans hfg
           assumption
 
+/- A function is strongly meromorphic at a point iff it is strongly meromorphic
+   after multiplication with a non-vanishing analytic function
+-/
+theorem stronglyMeromorphicAt_of_mul_analytic
+  {f g : ℂ → ℂ}
+  {z₀ : ℂ}
+  (h₁g : AnalyticAt ℂ g z₀)
+  (h₂g : g z₀ ≠ 0) :
+  StronglyMeromorphicAt f z₀ ↔ StronglyMeromorphicAt (f * g) z₀ := by
+  constructor
+  · apply stronglyMeromorphicAt_of_mul_analytic' h₁g h₂g
+  · intro hprod
+    let g' := fun z ↦ (g z)⁻¹
+    have h₁g' := h₁g.inv h₂g
+    have h₂g' : g' z₀ ≠ 0 := by
+      exact inv_ne_zero h₂g
+
+    let B := stronglyMeromorphicAt_of_mul_analytic' h₁g' h₂g' (f := f * g) hprod
+    have : f =ᶠ[𝓝 z₀] f * g * fun x => (g x)⁻¹ := by
+      unfold Filter.EventuallyEq
+      apply Filter.eventually_iff_exists_mem.mpr
+      use g⁻¹' {0}ᶜ
+      constructor
+      · apply ContinuousAt.preimage_mem_nhds
+        exact AnalyticAt.continuousAt h₁g
+        exact compl_singleton_mem_nhds_iff.mpr h₂g
+      · intro y hy
+        simp at hy
+        simp [hy]
+    rwa [stronglyMeromorphicAt_congr this]
+
+
+theorem StronglyMeromorphicAt.order_eq_zero_iff
+  {f : ℂ → ℂ}
+  {z₀ : ℂ}
+  (hf : StronglyMeromorphicAt f z₀) :
+  hf.meromorphicAt.order = 0 ↔ f z₀ ≠ 0 := by
+  constructor
+  · intro h₁f
+    let A := hf.analytic (le_of_eq (id (Eq.symm h₁f)))
+    apply A.order_eq_zero_iff.1
+    let B := A.meromorphicAt_order
+    rw [h₁f] at B
+    apply WithTopCoe
+    rw [eq_comm]
+    exact B
+  · intro h
+    have hf' := hf
+    rcases hf with h₁|h₁
+    · have : f z₀ = 0 := by
+        apply Filter.EventuallyEq.eq_of_nhds h₁
+      tauto
+    · obtain ⟨n, g, h₁g, h₂g, h₃g⟩ := h₁
+      have : n = 0 := by
+        by_contra hContra
+        let A := Filter.EventuallyEq.eq_of_nhds h₃g
+        have : (0 : ℂ) ^ n = 0 := by
+          exact zero_zpow n hContra
+        simp at A
+        simp_rw [this] at A
+        simp at A
+        tauto
+      rw [this] at h₃g
+      simp at h₃g
+
+      have : hf'.meromorphicAt.order = 0 := by
+        apply (hf'.meromorphicAt.order_eq_int_iff 0).2
+        use g
+        constructor
+        · assumption
+        · constructor
+          · assumption
+          · simp
+            apply Filter.EventuallyEq.filter_mono h₃g
+            exact nhdsWithin_le_nhds
+      exact this
+
+
+theorem StronglyMeromorphicAt.localIdentity
+  {f g : ℂ → ℂ}
+  {z₀ : ℂ}
+  (hf : StronglyMeromorphicAt f z₀)
+  (hg : StronglyMeromorphicAt g z₀) :
+  f =ᶠ[𝓝[≠] z₀] g → f =ᶠ[𝓝 z₀] g := by
+
+  intro h
+
+  have t₀ : hf.meromorphicAt.order = hg.meromorphicAt.order := by
+    exact hf.meromorphicAt.order_congr h
+
+  by_cases cs : hf.meromorphicAt.order = 0
+  · rw [cs] at t₀
+    have h₁f := hf.analytic (le_of_eq (id (Eq.symm cs)))
+    have h₁g := hg.analytic (le_of_eq t₀)
+    exact h₁f.localIdentity h₁g h
+  · apply Mnhds h
+    let A := cs
+    rw [hf.order_eq_zero_iff] at A
+    simp at A
+    let B := cs
+    rw [t₀] at B
+    rw [hg.order_eq_zero_iff] at B
+    simp at B
+    rw [A, B]
+
+
 
 /- Make strongly MeromorphicAt -/
 noncomputable def MeromorphicAt.makeStronglyMeromorphicAt
@@ -156,46 +310,6 @@ lemma m₂
   exact fun x a => m₁ hf x a
 
 
-lemma Mnhds
-  {f g : ℂ → ℂ}
-  {z₀ : ℂ}
-  (h₁ : f =ᶠ[𝓝[≠] z₀] g)
-  (h₂ : f z₀ = g z₀) :
-  f =ᶠ[𝓝 z₀] g := by
-  apply eventually_nhds_iff.2
-  obtain ⟨t, h₁t, h₂t⟩ := eventually_nhds_iff.1 (eventually_nhdsWithin_iff.1 h₁)
-  use t
-  constructor
-  · intro y hy
-    by_cases h₂y : y ∈ ({z₀}ᶜ : Set ℂ)
-    · exact h₁t y hy h₂y
-    · simp at h₂y
-      rwa [h₂y]
-  · exact h₂t
-
-
-theorem localIdentity
-  {f g : ℂ → ℂ}
-  {z₀ : ℂ}
-  (hf : AnalyticAt ℂ f z₀)
-  (hg : AnalyticAt ℂ g z₀) :
-  f =ᶠ[𝓝[≠] z₀] g → f =ᶠ[𝓝 z₀] g := by
-  intro h
-  let Δ := f - g
-  have : AnalyticAt ℂ Δ z₀ := AnalyticAt.sub hf hg
-  have t₁ : Δ =ᶠ[𝓝[≠] z₀] 0 := by
-    exact Filter.eventuallyEq_iff_sub.mp h
-
-  have : Δ =ᶠ[𝓝 z₀] 0 := by
-    rcases (AnalyticAt.eventually_eq_zero_or_eventually_ne_zero this) with h | h
-    · exact h
-    · have := Filter.EventuallyEq.eventually t₁
-      let A := Filter.eventually_and.2 ⟨this, h⟩
-      let _ := Filter.Eventually.exists A
-      tauto
-  exact Filter.eventuallyEq_iff_sub.mpr this
-
-
 theorem StronglyMeromorphicAt_of_makeStronglyMeromorphic
   {f : ℂ → ℂ}
   {z₀ : ℂ}
@@ -240,7 +354,7 @@ theorem StronglyMeromorphicAt_of_makeStronglyMeromorphic
             rw [hn] at h₃g; simp at h₃g
             simp
             have : g =ᶠ[𝓝 z₀] (Classical.choose h₄f) := by
-              apply localIdentity h₁g h₁G
+              apply h₁g.localIdentity h₁G
               exact Filter.EventuallyEq.trans (Filter.EventuallyEq.symm h₃g) h₃G
             rw [Filter.EventuallyEq.eq_of_nhds this]
           · have : hf.order ≠ 0 := h₃f
@@ -251,7 +365,7 @@ theorem StronglyMeromorphicAt_of_makeStronglyMeromorphic
             rwa [WithTop.untop_eq_iff h₂f]
 
 
-theorem makeStronglyMeromorphic_id
+theorem StronglyMeromorphicAt.makeStronglyMeromorphic_id
   {f : ℂ → ℂ}
   {z₀ : ℂ}
   (hf : StronglyMeromorphicAt f z₀) :
@@ -262,7 +376,7 @@ theorem makeStronglyMeromorphic_id
   · rw [hz]
     unfold MeromorphicAt.makeStronglyMeromorphicAt
     simp
-    let h₀f := hf
+    have h₀f := hf
     rcases hf with h₁f|h₁f
     · have A : f =ᶠ[𝓝[≠] z₀] 0 := by
         apply Filter.EventuallyEq.filter_mono h₁f
@@ -292,7 +406,7 @@ theorem makeStronglyMeromorphic_id
         let A := (h₀f.meromorphicAt.order_eq_int_iff 0).1 t₀
         have : g =ᶠ[𝓝 z₀] (Classical.choose A) := by
           obtain ⟨h₀, h₁, h₂⟩  := Classical.choose_spec A
-          apply localIdentity h₁g h₀
+          apply h₁g.localIdentity h₀
           rw [hn] at h₃g
           simp at h₃g
           simp at h₂
@@ -307,5 +421,93 @@ theorem makeStronglyMeromorphic_id
         by_contra hn
         rw [hn] at this
         tauto
-
   · exact m₁ (StronglyMeromorphicAt.meromorphicAt hf) z hz
+
+
+theorem StronglyMeromorphicAt.eliminate
+  {f : ℂ → ℂ}
+  {z₀ : ℂ}
+  (h₁f : StronglyMeromorphicAt f z₀)
+  (h₂f : h₁f.meromorphicAt.order ≠ ⊤) :
+  ∃ g : ℂ → ℂ, (AnalyticAt ℂ g z₀)
+    ∧ (g z₀ ≠ 0)
+    ∧ (f = (fun z ↦ (z-z₀) ^ (h₁f.meromorphicAt.order.untop h₂f)) * g) := by
+
+  let g₁ := (fun z ↦ (z-z₀) ^ (-h₁f.meromorphicAt.order.untop h₂f)) * f
+  let g₁₁ := fun z ↦ (z-z₀) ^ (-h₁f.meromorphicAt.order.untop h₂f)
+  have h₁g₁₁ : MeromorphicAt g₁₁ z₀ := by
+    apply MeromorphicAt.zpow
+    apply AnalyticAt.meromorphicAt
+    apply AnalyticAt.sub
+    apply analyticAt_id
+    exact analyticAt_const
+  have h₂g₁₁ : h₁g₁₁.order = - h₁f.meromorphicAt.order.untop h₂f := by
+    rw [← WithTop.LinearOrderedAddCommGroup.coe_neg]
+    rw [h₁g₁₁.order_eq_int_iff]
+    use 1
+    constructor
+    · exact analyticAt_const
+    · constructor
+      · simp
+      · apply eventually_nhdsWithin_of_forall
+        simp [g₁₁]
+  have h₁g₁ : MeromorphicAt g₁ z₀ := h₁g₁₁.mul h₁f.meromorphicAt
+  have h₂g₁ : h₁g₁.order = 0 := by
+    rw [h₁g₁₁.order_mul h₁f.meromorphicAt]
+    rw [h₂g₁₁]
+    simp
+    rw [add_comm]
+    rw [LinearOrderedAddCommGroupWithTop.add_neg_cancel_of_ne_top h₂f]
+  let g := h₁g₁.makeStronglyMeromorphicAt
+  use g
+  have h₁g : StronglyMeromorphicAt g z₀ := by
+    exact StronglyMeromorphicAt_of_makeStronglyMeromorphic h₁g₁
+  have h₂g : h₁g.meromorphicAt.order = 0 := by
+    rw [← h₁g₁.order_congr (m₂ h₁g₁)]
+    exact h₂g₁
+  constructor
+  · apply analytic
+    · rw [h₂g]
+    · exact h₁g
+  · constructor
+    · rwa [← h₁g.order_eq_zero_iff]
+    · funext z
+      by_cases hz : z = z₀
+      · by_cases hOrd : h₁f.meromorphicAt.order.untop h₂f = 0
+        · simp [hOrd]
+          have : StronglyMeromorphicAt g₁ z₀ := by
+            unfold g₁
+            simp [hOrd]
+            have : (fun z => 1) * f = f := by
+              funext z
+              simp
+            rwa [this]
+          rw [hz]
+          unfold g
+          let A := makeStronglyMeromorphic_id this
+          rw [← A]
+          unfold g₁
+          rw [hOrd]
+          simp
+        · have : h₁f.meromorphicAt.order ≠ 0 := by
+            by_contra hC
+            simp_rw [hC] at hOrd
+            tauto
+          let A := h₁f.order_eq_zero_iff.not.1 this
+          simp at A
+          rw [hz, A]
+          simp
+          left
+          rw [zpow_eq_zero_iff]
+          assumption
+      · simp
+        have : g z = g₁ z := by
+          exact Eq.symm (m₁ h₁g₁ z hz)
+        rw [this]
+        unfold g₁
+        simp [hz]
+        rw [← mul_assoc]
+        rw [mul_inv_cancel₀]
+        simp
+        apply zpow_ne_zero
+        exact sub_ne_zero_of_ne hz

Nevanlinna/stronglyMeromorphicOn.lean

@@ -1,9 +1,25 @@
 import Nevanlinna.stronglyMeromorphicAt
-
+import Mathlib.Algebra.BigOperators.Finprod
 
 open Topology
 
 
+
+theorem MeromorphicOn.analyticOnCodiscreteWithin
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (hf : MeromorphicOn f U) :
+  { x | AnalyticAt ℂ f x } ∈ Filter.codiscreteWithin U := by
+
+  rw [mem_codiscreteWithin]
+  intro x hx
+  simp
+  rw [← Filter.eventually_mem_set]
+  apply Filter.Eventually.mono (hf x hx).eventually_analyticAt
+  simp
+  tauto
+
+
 /- Strongly MeromorphicOn -/
 def StronglyMeromorphicOn
   (f : ℂ → ℂ)
@@ -26,8 +42,8 @@ theorem StronglyMeromorphicOn.analytic
   {f : ℂ → ℂ}
   {U : Set ℂ}
   (h₁f : StronglyMeromorphicOn f U)
-  (h₂f : ∀ x, (hx : x ∈ U) → 0 ≤ (h₁f x hx).meromorphicAt.order):
-  ∀ z ∈ U, AnalyticAt ℂ f z := by
+  (h₂f : ∀ x, (hx : x ∈ U) → 0 ≤ (h₁f x hx).meromorphicAt.order) :
+  AnalyticOnNhd ℂ f U := by
   intro z hz
   apply StronglyMeromorphicAt.analytic
   exact h₂f z hz
@@ -45,33 +61,20 @@ theorem AnalyticOn.stronglyMeromorphicOn
   exact h₁f z hz
 
 
-/- Strongly meromorphic functions on compact, preconnected sets are quotients of analytic functions -/
-theorem StronglyMeromorphicOn_finite
-  {f : ℂ → ℂ}
+theorem stronglyMeromorphicOn_of_mul_analytic'
+  {f g : ℂ → ℂ}
   {U : Set ℂ}
-  (h₁U : IsCompact U)
-  (h₂U : IsPreconnected U)
-  (h₁f : StronglyMeromorphicOn f U)
-  (h₂f : ∃ z ∈ U, f z ≠ 0) :
-  Set.Finite {z ∈ U | f z = 0} := by
-
-  sorry
+  (h₁g : AnalyticOnNhd ℂ g U)
+  (h₂g : ∀ u : U, g u ≠ 0)
+  (h₁f : StronglyMeromorphicOn f U) :
+  StronglyMeromorphicOn (g * f) U := by
+  intro z hz
+  rw [mul_comm]
+  apply (stronglyMeromorphicAt_of_mul_analytic (h₁g z hz) ?h₂g).mp (h₁f z hz)
+  exact h₂g ⟨z, hz⟩
 
 
-/- Strongly meromorphic functions on compact, preconnected sets are quotients of analytic functions -/
-theorem StronglyMeromorphicOn_quotient
-  {f : ℂ → ℂ}
-  {U : Set ℂ}
-  (h₁U : IsCompact U)
-  (h₂U : IsPreconnected U)
-  (h₁f : StronglyMeromorphicOn f U)
-  (h₂f : ∃ z ∈ U, f z ≠ 0) :
-  ∃ a b : ℂ → ℂ, (AnalyticOnNhd ℂ a U) ∧ (AnalyticOnNhd ℂ b U) ∧ (∀ z ∈ U, a z ≠ 0 ∨ b z ≠ 0) ∧ f = a / b := by
-
-  sorry
-
-
-/- Make strongly MeromorphicAt -/
+/- Make strongly MeromorphicOn -/
 noncomputable def MeromorphicOn.makeStronglyMeromorphicOn
   {f : ℂ → ℂ}
   {U : Set ℂ}
@@ -100,7 +103,7 @@ theorem makeStronglyMeromorphicOn_changeDiscrete
     unfold MeromorphicOn.makeStronglyMeromorphicOn
     by_cases h₂v : v ∈ U
     · simp [h₂v]
-      rw [← makeStronglyMeromorphic_id]
+      rw [← StronglyMeromorphicAt.makeStronglyMeromorphic_id]
       exact AnalyticAt.stronglyMeromorphicAt (h₂V v hv)
     · simp [h₂v]
 
@@ -113,18 +116,48 @@ theorem makeStronglyMeromorphicOn_changeDiscrete'
   (hz₀ : z₀ ∈ U) :
   hf.makeStronglyMeromorphicOn =ᶠ[𝓝 z₀] (hf z₀ hz₀).makeStronglyMeromorphicAt := by
   apply Mnhds
-  let A := makeStronglyMeromorphicOn_changeDiscrete hf hz₀
-  apply Filter.EventuallyEq.trans A
-  exact m₂ (hf z₀ hz₀)
-  unfold MeromorphicOn.makeStronglyMeromorphicOn
-  simp [hz₀]
+  · apply Filter.EventuallyEq.trans (makeStronglyMeromorphicOn_changeDiscrete hf hz₀)
+    exact m₂ (hf z₀ hz₀)
+  · rw [MeromorphicOn.makeStronglyMeromorphicOn]
+    simp [hz₀]
 
 
-theorem StronglyMeromorphicOn_of_makeStronglyMeromorphicOn
+theorem makeStronglyMeromorphicOn_changeDiscrete''
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (hf : MeromorphicOn f U) :
+  f =ᶠ[Filter.codiscreteWithin U] hf.makeStronglyMeromorphicOn := by
+
+  rw [Filter.eventuallyEq_iff_exists_mem]
+  use { x | AnalyticAt ℂ f x }
+  constructor
+  · exact MeromorphicOn.analyticOnCodiscreteWithin hf
+  · intro x hx
+    simp at hx
+    rw [MeromorphicOn.makeStronglyMeromorphicOn]
+    by_cases h₁x : x ∈ U
+    · simp [h₁x]
+      rw [← StronglyMeromorphicAt.makeStronglyMeromorphic_id hx.stronglyMeromorphicAt]
+    · simp [h₁x]
+
+
+theorem stronglyMeromorphicOn_of_makeStronglyMeromorphicOn
   {f : ℂ → ℂ}
   {U : Set ℂ}
   (hf : MeromorphicOn f U) :
   StronglyMeromorphicOn hf.makeStronglyMeromorphicOn U := by
-  intro z₀ hz₀
-  rw [stronglyMeromorphicAt_congr (makeStronglyMeromorphicOn_changeDiscrete' hf hz₀)]
-  exact StronglyMeromorphicAt_of_makeStronglyMeromorphic (hf z₀ hz₀)
+  intro z hz
+  let A := makeStronglyMeromorphicOn_changeDiscrete' hf hz
+  rw [stronglyMeromorphicAt_congr A]
+  exact StronglyMeromorphicAt_of_makeStronglyMeromorphic (hf z hz)
+
+
+theorem makeStronglyMeromorphicOn_changeOrder
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  {z₀ : ℂ}
+  (hf : MeromorphicOn f U)
+  (hz₀ : z₀ ∈ U) :
+  (stronglyMeromorphicOn_of_makeStronglyMeromorphicOn hf z₀ hz₀).meromorphicAt.order = (hf z₀ hz₀).order := by
+  apply MeromorphicAt.order_congr
+  exact makeStronglyMeromorphicOn_changeDiscrete hf hz₀

Nevanlinna/stronglyMeromorphicOn_eliminate.lean

@@ -0,0 +1,640 @@
+import Mathlib.Analysis.Analytic.Meromorphic
+import Nevanlinna.analyticAt
+import Nevanlinna.codiscreteWithin
+import Nevanlinna.divisor
+import Nevanlinna.meromorphicAt
+import Nevanlinna.meromorphicOn
+import Nevanlinna.meromorphicOn_divisor
+import Nevanlinna.stronglyMeromorphicOn
+import Nevanlinna.stronglyMeromorphicOn_ratlPolynomial
+import Nevanlinna.mathlibAddOn
+
+open scoped Interval Topology
+open Real Filter MeasureTheory intervalIntegral
+
+theorem MeromorphicOn.decompose₁
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  {z₀ : ℂ}
+  (h₁f : MeromorphicOn f U)
+  (h₂f : StronglyMeromorphicAt f z₀)
+  (h₃f : h₂f.meromorphicAt.order ≠ ⊤)
+  (hz₀ : z₀ ∈ U) :
+  ∃ g : ℂ → ℂ, (MeromorphicOn g U)
+    ∧ (AnalyticAt ℂ g z₀)
+    ∧ (g z₀ ≠ 0)
+    ∧ (f = g * fun z ↦ (z - z₀) ^ (h₁f.divisor z₀)) := by
+
+  let h₁ := fun z ↦ (z - z₀) ^ (-h₁f.divisor z₀)
+  have h₁h₁ : MeromorphicOn h₁ U := by
+    apply MeromorphicOn.zpow
+    apply AnalyticOnNhd.meromorphicOn
+    apply AnalyticOnNhd.sub
+    exact analyticOnNhd_id
+    exact analyticOnNhd_const
+  let n : ℤ := (-h₁f.divisor z₀)
+  have h₂h₁ : (h₁h₁ z₀ hz₀).order = n := by
+    simp_rw [(h₁h₁ z₀ hz₀).order_eq_int_iff]
+    use 1
+    constructor
+    · apply analyticAt_const
+    · constructor
+      · simp
+      · apply eventually_nhdsWithin_of_forall
+        intro z hz
+        simp
+
+  let g₁ := f * h₁
+  have h₁g₁ : MeromorphicOn g₁ U := by
+    apply h₁f.mul h₁h₁
+  have h₂g₁ : (h₁g₁ z₀ hz₀).order = 0 := by
+    rw [(h₁f z₀ hz₀).order_mul (h₁h₁ z₀ hz₀)]
+    rw [h₂h₁]
+    unfold n
+    rw [MeromorphicOn.divisor_def₂ h₁f hz₀ h₃f]
+    conv =>
+      left
+      left
+      rw [Eq.symm (WithTop.coe_untop (h₁f z₀ hz₀).order h₃f)]
+    have
+      (a b c : ℤ)
+      (h : a + b = c) :
+      (a : WithTop ℤ) + (b : WithTop ℤ) = (c : WithTop ℤ) := by
+      rw [← h]
+      simp
+    rw [this ((h₁f z₀ hz₀).order.untop h₃f) (-(h₁f z₀ hz₀).order.untop h₃f) 0]
+    simp
+    ring
+
+  let g := (h₁g₁ z₀ hz₀).makeStronglyMeromorphicAt
+  have h₂g : StronglyMeromorphicAt g z₀ := by
+    exact StronglyMeromorphicAt_of_makeStronglyMeromorphic (h₁g₁ z₀ hz₀)
+  have h₁g : MeromorphicOn g U := by
+    intro z hz
+    by_cases h₁z : z = z₀
+    · rw [h₁z]
+      apply h₂g.meromorphicAt
+    · apply (h₁g₁ z hz).congr
+      rw [eventuallyEq_nhdsWithin_iff]
+      rw [eventually_nhds_iff]
+      use {z₀}ᶜ
+      constructor
+      · intro y h₁y h₂y
+        let A := m₁ (h₁g₁ z₀ hz₀) y h₁y
+        unfold g
+        rw [← A]
+      · constructor
+        · exact isOpen_compl_singleton
+        · exact h₁z
+  have h₃g : (h₁g z₀ hz₀).order = 0 := by
+    unfold g
+    let B := m₂ (h₁g₁ z₀ hz₀)
+    let A := (h₁g₁ z₀ hz₀).order_congr B
+    rw [← A]
+    rw [h₂g₁]
+  have h₄g : AnalyticAt ℂ g z₀ := by
+    apply h₂g.analytic
+    rw [h₃g]
+
+  use g
+  constructor
+  · exact h₁g
+  · constructor
+    · exact h₄g
+    · constructor
+      · exact (h₂g.order_eq_zero_iff).mp h₃g
+      · funext z
+        by_cases hz : z = z₀
+        · rw [hz]
+          simp
+          by_cases h : h₁f.divisor z₀ = 0
+          · simp [h]
+            have h₂h₁ : h₁ = 1 := by
+              funext w
+              unfold h₁
+              simp [h]
+            have h₃g₁ : g₁ = f := by
+              unfold g₁
+              rw [h₂h₁]
+              simp
+            have h₄g₁ : StronglyMeromorphicAt g₁ z₀ := by
+              rwa [h₃g₁]
+            let A := h₄g₁.makeStronglyMeromorphic_id
+            unfold g
+            rw [← A, h₃g₁]
+          · have : (0 : ℂ) ^ h₁f.divisor z₀ = (0 : ℂ) := by
+              exact zero_zpow (h₁f.divisor z₀) h
+            rw [this]
+            simp
+            let A := h₂f.order_eq_zero_iff.not
+            simp at A
+            rw [← A]
+            unfold MeromorphicOn.divisor at h
+            simp [hz₀] at h
+            exact h.1
+        · simp
+          let B := m₁ (h₁g₁ z₀ hz₀) z hz
+          unfold g
+          rw [← B]
+          unfold g₁ h₁
+          simp [hz]
+          rw [mul_assoc]
+          rw [inv_mul_cancel₀]
+          simp
+          apply zpow_ne_zero
+          rwa [sub_ne_zero]
+
+
+theorem MeromorphicOn.decompose₂
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  {P : Finset U}
+  (hf : StronglyMeromorphicOn f U) :
+  (∀ p ∈ P, (hf p p.2).meromorphicAt.order ≠ ⊤) →
+    ∃ g : ℂ → ℂ, (MeromorphicOn g U)
+    ∧ (∀ p : P, AnalyticAt ℂ g p)
+    ∧ (∀ p : P, g p ≠ 0)
+    ∧ (f = g * ∏ p : P, fun z ↦ (z - p.1.1) ^ (hf.meromorphicOn.divisor p.1.1)) := by
+
+  apply Finset.induction (p := fun (P : Finset U) ↦
+    (∀ p ∈ P, (hf p p.2).meromorphicAt.order ≠ ⊤) →
+    ∃ g : ℂ → ℂ, (MeromorphicOn g U)
+    ∧ (∀ p : P, AnalyticAt ℂ g p)
+    ∧ (∀ p : P, g p ≠ 0)
+    ∧ (f = g * ∏ p : P, fun z ↦ (z - p.1.1) ^ (hf.meromorphicOn.divisor p.1.1)))
+
+  -- case empty
+  simp
+  exact hf.meromorphicOn
+
+  -- case insert
+  intro u P hu iHyp
+  intro hOrder
+  obtain ⟨g₀, h₁g₀, h₂g₀, h₃g₀, h₄g₀⟩ := iHyp (fun p hp ↦ hOrder p (Finset.mem_insert_of_mem hp))
+
+  have h₀ : AnalyticAt ℂ (∏ p : P, fun z ↦ (z - p.1.1) ^ (hf.meromorphicOn.divisor p.1.1)) u := by
+    have : (∏ p : P, fun z ↦ (z - p.1.1) ^ (hf.meromorphicOn.divisor p.1.1)) = (fun z => ∏ p : P, (z - p.1.1) ^ (hf.meromorphicOn.divisor p.1.1)) := by
+      funext w
+      simp
+    rw [this]
+    apply Finset.analyticAt_prod
+    intro p hp
+    apply AnalyticAt.zpow
+    apply AnalyticAt.sub
+    apply analyticAt_id
+    apply analyticAt_const
+    by_contra hCon
+    rw [sub_eq_zero] at hCon
+    have : p.1 = u := by
+      exact SetCoe.ext (_root_.id (Eq.symm hCon))
+    rw [← this] at hu
+    simp [hp] at hu
+
+  have h₁ : (∏ p : P, fun z ↦ (z - p.1.1) ^ (hf.meromorphicOn.divisor p.1.1)) u ≠ 0 := by
+    simp only [Finset.prod_apply]
+    rw [Finset.prod_ne_zero_iff]
+    intro p hp
+    apply zpow_ne_zero
+    by_contra hCon
+    rw [sub_eq_zero] at hCon
+    have : p.1 = u := by
+      exact SetCoe.ext (_root_.id (Eq.symm hCon))
+    rw [← this] at hu
+    simp [hp] at hu
+
+  have h₅g₀ : StronglyMeromorphicAt g₀ u := by
+    rw [stronglyMeromorphicAt_of_mul_analytic h₀ h₁]
+    rw [← h₄g₀]
+    exact hf u u.2
+
+  have h₆g₀ : (h₁g₀ u u.2).order ≠ ⊤ := by
+    by_contra hCon
+    let A := (h₁g₀ u u.2).order_mul h₀.meromorphicAt
+    simp_rw [← h₄g₀, hCon] at A
+    simp at A
+    let B := hOrder u (Finset.mem_insert_self u P)
+    tauto
+
+  obtain ⟨g, h₁g, h₂g, h₃g, h₄g⟩ := h₁g₀.decompose₁ h₅g₀ h₆g₀ u.2
+  use g
+  · constructor
+    · exact h₁g
+    · constructor
+      · intro ⟨v₁, v₂⟩
+        simp
+        simp at v₂
+        rcases v₂ with hv|hv
+        · rwa [hv]
+        · let A := h₂g₀ ⟨v₁, hv⟩
+          rw [h₄g] at A
+          rw [← analyticAt_of_mul_analytic] at A
+          simp at A
+          exact A
+          --
+          simp
+          apply AnalyticAt.zpow
+          apply AnalyticAt.sub
+          apply analyticAt_id
+          apply analyticAt_const
+          by_contra hCon
+          rw [sub_eq_zero] at hCon
+
+          have : v₁ = u := by
+            exact SetCoe.ext hCon
+          rw [this] at hv
+          tauto
+          --
+          apply zpow_ne_zero
+          simp
+          by_contra hCon
+          rw [sub_eq_zero] at hCon
+          have : v₁ = u := by
+            exact SetCoe.ext hCon
+          rw [this] at hv
+          tauto
+
+      · constructor
+        · intro ⟨v₁, v₂⟩
+          simp
+          simp at v₂
+          rcases v₂ with hv|hv
+          · rwa [hv]
+          · by_contra hCon
+            let A := h₃g₀ ⟨v₁,hv⟩
+            rw [h₄g] at A
+            simp at A
+            tauto
+        · conv =>
+            left
+            rw [h₄g₀, h₄g]
+          simp
+          rw [mul_assoc]
+          congr
+          rw [Finset.prod_insert]
+          simp
+          congr
+          have : (hf u u.2).meromorphicAt.order = (h₁g₀ u u.2).order := by
+            have h₅g₀ : f =ᶠ[𝓝 u.1] (g₀ * ∏ p : P, fun z => (z - p.1.1) ^ (hf.meromorphicOn.divisor p.1.1)) := by
+              exact Eq.eventuallyEq h₄g₀
+            have h₆g₀ : f =ᶠ[𝓝[≠] u.1] (g₀ * ∏ p : P, fun z => (z - p.1.1) ^ (hf.meromorphicOn.divisor p.1.1)) := by
+              exact eventuallyEq_nhdsWithin_of_eqOn fun ⦃x⦄ a => congrFun h₄g₀ x
+            rw [(hf u u.2).meromorphicAt.order_congr h₆g₀]
+            let C := (h₁g₀ u u.2).order_mul h₀.meromorphicAt
+            rw [C]
+            let D := h₀.order_eq_zero_iff.2 h₁
+            let E := h₀.meromorphicAt_order
+            rw [E, D]
+            simp
+          have : hf.meromorphicOn.divisor u = h₁g₀.divisor u := by
+            unfold MeromorphicOn.divisor
+            simp
+            rw [this]
+          rw [this]
+          --
+          simpa
+
+
+theorem MeromorphicOn.decompose₃'
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (h₁U : IsCompact U)
+  (h₂U : IsConnected U)
+  (h₁f : StronglyMeromorphicOn f U)
+  (h₂f : ∃ u : U, f u ≠ 0) :
+  ∃ g : ℂ → ℂ, (MeromorphicOn g U)
+    ∧ (AnalyticOnNhd ℂ g U)
+    ∧ (∀ u : U, g u ≠ 0)
+    ∧ (f = g * ∏ᶠ u, fun z ↦ (z - u) ^ (h₁f.meromorphicOn.divisor u)) := by
+
+  have h₃f : ∀ u : U, (h₁f u u.2).meromorphicAt.order ≠ ⊤ :=
+    StronglyMeromorphicOn.order_ne_top h₁f h₂U h₂f
+  have h₄f : Set.Finite (Function.support h₁f.meromorphicOn.divisor) := h₁f.meromorphicOn.divisor.finiteSupport h₁U
+
+  let d := - h₁f.meromorphicOn.divisor.toFun
+  have h₁d : d.support = (Function.support h₁f.meromorphicOn.divisor) := by
+    ext x
+    unfold d
+    simp
+  let h₁ := ∏ᶠ u, fun z ↦ (z - u) ^ (d u)
+  have h₁h₁ : StronglyMeromorphicOn h₁ U := by
+    intro z hz
+    exact stronglyMeromorphicOn_ratlPolynomial₃ d z trivial
+  have h₂h₁ : h₁h₁.meromorphicOn.divisor = d := by
+    apply stronglyMeromorphicOn_divisor_ratlPolynomial_U
+    rwa [h₁d]
+    --
+    rw [h₁d]
+    exact (StronglyMeromorphicOn.meromorphicOn h₁f).divisor.supportInU
+  have h₃h₁ : ∀ (z : ℂ) (hz : z ∈ U), (h₁h₁ z hz).meromorphicAt.order ≠ ⊤ := by
+    intro z hz
+    apply stronglyMeromorphicOn_ratlPolynomial₃order
+  have h₄h₁ : ∀ (z : ℂ) (hz : z ∈ U), (h₁h₁ z hz).meromorphicAt.order = d z := by
+    intro z hz
+    rw [stronglyMeromorphicOn_divisor_ratlPolynomial₁]
+    rwa [h₁d]
+
+  let g' := f * h₁
+  have h₁g' : MeromorphicOn g' U := h₁f.meromorphicOn.mul h₁h₁.meromorphicOn
+  have h₂g' : h₁g'.divisor.toFun = 0 := by
+    rw [MeromorphicOn.divisor_mul h₁f.meromorphicOn (fun z hz ↦ h₃f ⟨z, hz⟩) h₁h₁.meromorphicOn h₃h₁]
+    rw [h₂h₁]
+    unfold d
+    simp
+  have h₃g' : ∀ u : U, (h₁g' u.1 u.2).order = 0 := by
+    intro u
+    rw [(h₁f u.1 u.2).meromorphicAt.order_mul (h₁h₁ u.1 u.2).meromorphicAt]
+    rw [h₄h₁]
+    unfold d
+    unfold MeromorphicOn.divisor
+    simp
+    have : (h₁f u.1 u.2).meromorphicAt.order = WithTop.untop' 0 (h₁f u.1 u.2).meromorphicAt.order := by
+      rw [eq_comm]
+      let A := h₃f u
+      exact untop'_of_ne_top A
+    rw [this]
+    simp
+    rw [← WithTop.LinearOrderedAddCommGroup.coe_neg]
+    rw [← WithTop.coe_add]
+    simp
+    exact u.2
+
+  let g := h₁g'.makeStronglyMeromorphicOn
+  have h₁g : StronglyMeromorphicOn g U := stronglyMeromorphicOn_of_makeStronglyMeromorphicOn h₁g'
+  have h₂g : h₁g.meromorphicOn.divisor.toFun = 0 := by
+    rw [← MeromorphicOn.divisor_of_makeStronglyMeromorphicOn]
+    rw [h₂g']
+  have h₃g : AnalyticOnNhd ℂ g U := by
+    apply StronglyMeromorphicOn.analyticOnNhd
+    rw [h₂g]
+    simp
+    assumption
+  have h₄g : ∀ u : U, g u ≠ 0 := by
+    intro u
+    rw [← (h₁g u.1 u.2).order_eq_zero_iff]
+    rw [makeStronglyMeromorphicOn_changeOrder]
+    let A := h₃g' u
+    exact A
+    exact u.2
+
+  use g
+  constructor
+  · exact StronglyMeromorphicOn.meromorphicOn h₁g
+  · constructor
+    · exact h₃g
+    · constructor
+      · exact h₄g
+      · have t₀ : StronglyMeromorphicOn (g * ∏ᶠ (u : ℂ), fun z => (z - u) ^ (h₁f.meromorphicOn.divisor u)) U := by
+          apply stronglyMeromorphicOn_of_mul_analytic' h₃g h₄g
+          apply stronglyMeromorphicOn_ratlPolynomial₃U
+
+        funext z
+        by_cases hz : z ∈ U
+        · apply Filter.EventuallyEq.eq_of_nhds
+          apply StronglyMeromorphicAt.localIdentity (h₁f z hz) (t₀ z hz)
+          have h₅g : g =ᶠ[𝓝[≠] z] g' := makeStronglyMeromorphicOn_changeDiscrete h₁g' hz
+          have Y' : (g' * ∏ᶠ (u : ℂ), fun z => (z - u) ^ (h₁f.meromorphicOn.divisor u)) =ᶠ[𝓝[≠] z] g * ∏ᶠ (u : ℂ), fun z => (z - u) ^ (h₁f.meromorphicOn.divisor u) := by
+            apply Filter.EventuallyEq.symm
+            exact Filter.EventuallyEq.mul h₅g (by simp)
+          apply Filter.EventuallyEq.trans _ Y'
+          unfold g'
+          unfold h₁
+
+          let A := h₁f.meromorphicOn.divisor.locallyFiniteInU z hz
+          let B := eventually_nhdsWithin_iff.1 A
+          obtain ⟨t, h₁t, h₂t, h₃t⟩ := eventually_nhds_iff.1 B
+
+          apply eventually_nhdsWithin_iff.2
+          rw [eventually_nhds_iff]
+          use t
+          constructor
+          · intro y h₁y h₂y
+            let C := h₁t y h₁y h₂y
+            rw [mul_assoc]
+            simp
+            have : (finprod (fun u z => (z - u) ^ d u) y * finprod (fun u z => (z - u) ^ (h₁f.meromorphicOn.divisor u)) y) = 1 := by
+              have t₀ : (Function.mulSupport fun u z => (z - u) ^ d u).Finite := by
+                rwa [ratlPoly_mulsupport, h₁d]
+              rw [finprod_eq_prod _ t₀]
+              have t₁ : (Function.mulSupport fun u z => (z - u) ^ h₁f.meromorphicOn.divisor u).Finite := by
+                rwa [ratlPoly_mulsupport]
+              rw [finprod_eq_prod _ t₁]
+              have : (Function.mulSupport fun u z => (z - u) ^ d u) = (Function.mulSupport fun u z => (z - u) ^ h₁f.meromorphicOn.divisor u) := by
+                rw [ratlPoly_mulsupport]
+                rw [ratlPoly_mulsupport]
+                unfold d
+                simp
+              have : t₀.toFinset = t₁.toFinset := by congr
+              rw [this]
+              simp
+              rw [← Finset.prod_mul_distrib]
+              apply Finset.prod_eq_one
+              intro x hx
+              apply zpow_neg_mul_zpow_self
+              have : y ∉ t₁.toFinset := by
+                simp
+                simp at C
+                rw [C]
+                simp
+                tauto
+              by_contra H
+              rw [sub_eq_zero] at H
+              rw [H] at this
+              tauto
+
+            rw [this]
+            simp
+          · exact ⟨h₂t, h₃t⟩
+        · simp
+          have : g z = g' z := by
+            unfold g
+            unfold MeromorphicOn.makeStronglyMeromorphicOn
+            simp [hz]
+          rw [this]
+          unfold g'
+          unfold h₁
+          simp
+          rw [mul_assoc]
+          nth_rw 1 [← mul_one (f z)]
+          congr
+          have t₀ : (Function.mulSupport fun u z => (z - u) ^ d u).Finite := by
+            rwa [ratlPoly_mulsupport, h₁d]
+          rw [finprod_eq_prod _ t₀]
+          have t₁ : (Function.mulSupport fun u z => (z - u) ^ h₁f.meromorphicOn.divisor u).Finite := by
+            rwa [ratlPoly_mulsupport]
+          rw [finprod_eq_prod _ t₁]
+          have : (Function.mulSupport fun u z => (z - u) ^ d u) = (Function.mulSupport fun u z => (z - u) ^ h₁f.meromorphicOn.divisor u) := by
+            rw [ratlPoly_mulsupport]
+            rw [ratlPoly_mulsupport]
+            unfold d
+            simp
+          have : t₀.toFinset = t₁.toFinset := by congr
+          rw [this]
+          simp
+          rw [← Finset.prod_mul_distrib]
+          rw [eq_comm]
+          apply Finset.prod_eq_one
+          intro x hx
+          apply zpow_neg_mul_zpow_self
+
+          have : z ∉ t₁.toFinset := by
+            simp
+            have : h₁f.meromorphicOn.divisor z = 0 := by
+              let A := h₁f.meromorphicOn.divisor.supportInU
+              simp at A
+              by_contra H
+              let B := A z H
+              tauto
+            rw [this]
+            simp
+            rfl
+          by_contra H
+          rw [sub_eq_zero] at H
+          rw [H] at this
+          tauto
+
+
+theorem StronglyMeromorphicOn.decompose_log
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (h₁U : IsCompact U)
+  (h₂U : IsConnected U)
+  (h₁f : StronglyMeromorphicOn f U)
+  (h₂f : ∃ u : U, f u ≠ 0) :
+  ∃ g : ℂ → ℂ, (MeromorphicOn g U)
+    ∧ (AnalyticOnNhd ℂ g U)
+    ∧ (∀ u : U, g u ≠ 0)
+    ∧ (fun z ↦ log ‖f z‖) =ᶠ[Filter.codiscreteWithin U] fun z ↦ log ‖g z‖ + ∑ᶠ s, (h₁f.meromorphicOn.divisor s) * log ‖z - s‖ := by
+
+  have h₃f : Set.Finite (Function.support h₁f.meromorphicOn.divisor) := by
+    exact Divisor.finiteSupport h₁U (StronglyMeromorphicOn.meromorphicOn h₁f).divisor
+
+  have hSupp₁ {z : ℂ} : (fun s ↦ (h₁f.meromorphicOn.divisor s) * log ‖z - s‖).support ⊆ h₃f.toFinset := by
+    intro x
+    contrapose
+    simp; tauto
+  simp_rw [finsum_eq_sum_of_support_subset _ hSupp₁]
+
+  obtain ⟨g, h₁g, h₂g, h₃g, h₄g⟩ := MeromorphicOn.decompose₃' h₁U h₂U h₁f h₂f
+  have hSupp₂ {z : ℂ} : ( fun (u : ℂ) ↦ (fun (z : ℂ) ↦ (z - u) ^ (h₁f.meromorphicOn.divisor u)) ).mulSupport ⊆ h₃f.toFinset := by
+    intro x
+    contrapose
+    simp
+    intro hx
+    rw [hx]
+    simp; tauto
+  rw [finprod_eq_prod_of_mulSupport_subset _ hSupp₂] at h₄g
+
+  use g
+  simp only [h₁g, h₂g, h₃g, ne_eq, true_and, not_false_eq_true, implies_true]
+  rw [Filter.eventuallyEq_iff_exists_mem]
+  use {z | f z ≠ 0}
+  constructor
+  · have A := h₁f.meromorphicOn.divisor.codiscreteWithin
+    have : {z | f z ≠ 0} ∩ U = (Function.support h₁f.meromorphicOn.divisor)ᶜ ∩ U := by
+      rw [← h₁f.support_divisor h₂f h₂U]
+      ext u
+      simp; tauto
+
+    rw [codiscreteWithin_congr this]
+    exact A
+
+  · intro z hz
+    nth_rw 1 [h₄g]
+    simp
+    rw [log_mul, log_prod]
+    congr
+    ext u
+    rw [log_zpow]
+    --
+    intro x hx
+    simp at hx
+    have h₁x : x ∈ U := by
+      exact h₁f.meromorphicOn.divisor.supportInU hx
+
+    apply zpow_ne_zero
+    simp
+
+    by_contra hCon
+    rw [← hCon] at hx
+    unfold MeromorphicOn.divisor at hx
+    rw [hCon] at hz
+    simp at hz
+    let A := (h₁f x h₁x).order_eq_zero_iff
+    let B := A.2 hz
+    simp [B] at hx
+    obtain ⟨a, b⟩ := hx
+    let c := b.1
+    simp_rw [hCon] at c
+    tauto
+    --
+    simp at hz
+    by_contra hCon
+    simp at hCon
+    rw [h₄g] at hz
+    simp at hz
+    tauto
+    --
+    rw [Finset.prod_ne_zero_iff]
+    intro x hx
+    simp at hx
+    have h₁x : x ∈ U := by
+      exact h₁f.meromorphicOn.divisor.supportInU hx
+
+    apply zpow_ne_zero
+    simp
+
+    by_contra hCon
+    rw [← hCon] at hx
+    unfold MeromorphicOn.divisor at hx
+    rw [hCon] at hz
+    simp at hz
+    let A := (h₁f x h₁x).order_eq_zero_iff
+    let B := A.2 hz
+    simp [B] at hx
+    obtain ⟨a, b⟩ := hx
+    let c := b.1
+    simp_rw [hCon] at c
+    tauto
+
+  exact 0
+
+
+theorem MeromorphicOn.decompose_log
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (h₁U : IsCompact U)
+  (h₂U : IsConnected U)
+  (h₃U : interior U ≠ ∅)
+  (h₁f : MeromorphicOn f U)
+  (h₂f : ∃ u : U, (h₁f u u.2).order ≠ ⊤) :
+  ∃ g : ℂ → ℂ, (AnalyticOnNhd ℂ g U)
+    ∧ (∀ u : U, g u ≠ 0)
+    ∧ (fun z ↦ log ‖f z‖) =ᶠ[Filter.codiscreteWithin U] fun z ↦ log ‖g z‖ + ∑ᶠ s, (h₁f.divisor s) * log ‖z - s‖ := by
+
+  let F := h₁f.makeStronglyMeromorphicOn
+  have h₁F := stronglyMeromorphicOn_of_makeStronglyMeromorphicOn h₁f
+  have h₂F : ∃ u : U, (h₁F.meromorphicOn u u.2).order ≠ ⊤ := by
+    obtain ⟨u, hu⟩ := h₂f
+    use u
+    rw [makeStronglyMeromorphicOn_changeOrder h₁f u.2]
+    assumption
+
+  have t₁ : ∃ u : U, F u ≠ 0 := by
+    let A := h₁F.meromorphicOn.nonvanish_of_order_ne_top h₂F h₂U h₃U
+    tauto
+  have t₃ : (fun z ↦ log ‖f z‖) =ᶠ[Filter.codiscreteWithin U] (fun z ↦ log ‖F z‖) := by
+    -- This would be interesting for a tactic
+    rw [eventuallyEq_iff_exists_mem]
+    obtain ⟨s, h₁s, h₂s⟩ := eventuallyEq_iff_exists_mem.1 (makeStronglyMeromorphicOn_changeDiscrete'' h₁f)
+    use s
+    tauto
+
+  obtain ⟨g, h₁g, h₂g, h₃g, h₄g⟩ := h₁F.decompose_log h₁U h₂U t₁
+  use g
+  constructor
+  · exact h₂g
+  · constructor
+    · exact h₃g
+    · apply t₃.trans
+      rw [h₁f.divisor_of_makeStronglyMeromorphicOn]
+      exact h₄g

Nevanlinna/stronglyMeromorphicOn_ratlPolynomial.lean

@@ -0,0 +1,213 @@
+import Nevanlinna.stronglyMeromorphicOn
+import Nevanlinna.meromorphicOn
+import Nevanlinna.meromorphicOn_divisor
+import Nevanlinna.mathlibAddOn
+
+open scoped Interval Topology
+
+
+theorem analyticAt_ratlPolynomial₁
+  {z : ℂ}
+  (d : ℂ → ℤ)
+  (P : Finset ℂ) :
+  z ∉ P → AnalyticAt ℂ (∏ u ∈ P, fun z ↦ (z - u) ^ d u) z := by
+  intro hz
+  rw [Finset.prod_fn]
+  apply Finset.analyticAt_prod
+  intro u hu
+  apply AnalyticAt.zpow
+  apply AnalyticAt.sub
+  apply analyticAt_id
+  apply analyticAt_const
+  rw [sub_ne_zero, ne_comm]
+  exact ne_of_mem_of_not_mem hu hz
+
+
+theorem stronglyMeromorphicOn_ratlPolynomial₂
+  (d : ℂ → ℤ)
+  (P : Finset ℂ) :
+  StronglyMeromorphicOn (∏ u ∈ P, fun z ↦ (z - u) ^ d u) ⊤ := by
+
+  intro z hz
+  by_cases h₂z : z ∈ P
+  · rw [← Finset.mul_prod_erase P _ h₂z]
+    right
+    use d z
+    use ∏ x ∈ P.erase z, fun z => (z - x) ^ d x
+    constructor
+    · have : z ∉ P.erase z := Finset.not_mem_erase z P
+      apply analyticAt_ratlPolynomial₁ d (P.erase z) this
+    · constructor
+      · simp only [Finset.prod_apply]
+        rw [Finset.prod_ne_zero_iff]
+        intro u hu
+        apply zpow_ne_zero
+        rw [sub_ne_zero]
+        by_contra hCon
+        rw [hCon] at hu
+        let A := Finset.not_mem_erase u P
+        tauto
+      · exact Filter.Eventually.of_forall (congrFun rfl)
+  · apply AnalyticAt.stronglyMeromorphicAt
+    exact analyticAt_ratlPolynomial₁ d P (z := z) h₂z
+
+
+theorem stronglyMeromorphicOn_ratlPolynomial₃
+  (d : ℂ → ℤ) :
+  StronglyMeromorphicOn (∏ᶠ u, fun z ↦ (z - u) ^ d u) ⊤ := by
+  by_cases hd : (Function.mulSupport fun u z => (z - u) ^ d u).Finite
+  · rw [finprod_eq_prod _ hd]
+    apply stronglyMeromorphicOn_ratlPolynomial₂ d hd.toFinset
+  · rw [finprod_of_infinite_mulSupport hd]
+    apply AnalyticOn.stronglyMeromorphicOn
+    apply analyticOnNhd_const
+
+
+theorem stronglyMeromorphicOn_ratlPolynomial₃U
+  (d : ℂ → ℤ)
+  (U : Set ℂ) :
+  StronglyMeromorphicOn (∏ᶠ u, fun z ↦ (z - u) ^ d u) U := by
+  intro z hz
+  exact stronglyMeromorphicOn_ratlPolynomial₃ d z (trivial)
+
+
+theorem ratlPoly_mulsupport
+  (d : ℂ → ℤ) :
+  (Function.mulSupport fun u z ↦ (z - u) ^ d u) = d.support := by
+  ext u
+  constructor
+  · intro h
+    simp at h
+    simp
+    by_contra hCon
+    rw [hCon] at h
+    simp at h
+    tauto
+  · intro h
+    simp
+    by_contra hCon
+    let A := congrFun hCon u
+    simp at A
+    have t₁ : (0 : ℂ) ^ d u ≠ 0 := ne_zero_of_eq_one A
+    rw [zpow_ne_zero_iff h] at t₁
+    tauto
+
+
+theorem stronglyMeromorphicOn_divisor_ratlPolynomial₁
+  {z : ℂ}
+  (d : ℂ → ℤ)
+  (h₁d : Set.Finite d.support) :
+  (((stronglyMeromorphicOn_ratlPolynomial₃ d).meromorphicOn) z trivial).order = d z := by
+
+  rw [MeromorphicAt.order_eq_int_iff]
+  use ∏ x ∈ h₁d.toFinset.erase z, fun z => (z - x) ^ d x
+  constructor
+  · have : z ∉ h₁d.toFinset.erase z := Finset.not_mem_erase z h₁d.toFinset
+    apply analyticAt_ratlPolynomial₁ d (h₁d.toFinset.erase z) this
+  · constructor
+    · simp only [Finset.prod_apply]
+      rw [Finset.prod_ne_zero_iff]
+      intro u hu
+      apply zpow_ne_zero
+      rw [sub_ne_zero]
+      by_contra hCon
+      rw [hCon] at hu
+      let A := Finset.not_mem_erase u h₁d.toFinset
+      tauto
+    · apply Filter.Eventually.of_forall
+      intro x
+      have t₀ : (Function.mulSupport fun u z => (z - u) ^ d u).Finite := by
+        rwa [ratlPoly_mulsupport d]
+      rw [finprod_eq_prod _ t₀]
+      have t₁ : h₁d.toFinset = t₀.toFinset := by
+        simp
+        rw [eq_comm]
+        exact ratlPoly_mulsupport d
+      rw [t₁]
+      simp
+      rw [eq_comm]
+      have : z ∉ h₁d.toFinset.erase z := Finset.not_mem_erase z h₁d.toFinset
+      by_cases hz : z ∈ h₁d.toFinset
+      · rw [t₁] at hz
+        conv =>
+          right
+          rw [← Finset.mul_prod_erase t₀.toFinset _ hz]
+      · have : t₀.toFinset = t₀.toFinset.erase z := by
+          rw [eq_comm]
+          apply Finset.erase_eq_of_not_mem
+          rwa [t₁] at hz
+        rw [this]
+
+        have : (x - z) ^ d z = 1 := by
+          simp at hz
+          rw [hz]
+          simp
+        rw [this]
+        simp
+
+
+theorem stronglyMeromorphicOn_ratlPolynomial₃order
+  {z : ℂ}
+  (d : ℂ → ℤ) :
+  ((stronglyMeromorphicOn_ratlPolynomial₃ d) z trivial).meromorphicAt.order ≠ ⊤ := by
+
+  have h₂d : (Function.mulSupport fun u z ↦ (z - u) ^ d u) = d.support := by
+    ext u
+    constructor
+    · intro h
+      simp at h
+      simp
+      by_contra hCon
+      rw [hCon] at h
+      simp at h
+      tauto
+    · intro h
+      simp
+      by_contra hCon
+      let A := congrFun hCon u
+      simp at A
+      have t₁ : (0 : ℂ) ^ d u ≠ 0 := ne_zero_of_eq_one A
+      rw [zpow_ne_zero_iff h] at t₁
+      tauto
+
+  by_cases hd : Set.Finite (Function.support d)
+  · rw [stronglyMeromorphicOn_divisor_ratlPolynomial₁ d hd]
+    simp
+  · rw [← h₂d] at hd
+    have : (Function.mulSupport fun u z => (z - u) ^ d u).Infinite := by
+      exact hd
+    simp_rw [finprod_of_infinite_mulSupport this]
+    have : AnalyticAt ℂ (1 : ℂ → ℂ) z := by exact analyticAt_const
+    rw [AnalyticAt.meromorphicAt_order this]
+    rw [this.order_eq_zero_iff.2 (by simp)]
+    simp
+
+
+theorem stronglyMeromorphicOn_divisor_ratlPolynomial
+  (d : ℂ → ℤ)
+  (h₁d : Set.Finite d.support) :
+  (stronglyMeromorphicOn_ratlPolynomial₃ d).meromorphicOn.divisor = d := by
+  funext z
+  rw [MeromorphicOn.divisor]
+  simp
+  rw [stronglyMeromorphicOn_divisor_ratlPolynomial₁ d h₁d]
+  simp
+
+
+theorem stronglyMeromorphicOn_divisor_ratlPolynomial_U
+  {U : Set ℂ}
+  (d : ℂ → ℤ)
+  (h₁d : Set.Finite d.support)
+  (h₂d : d.support ⊆ U) :
+  (stronglyMeromorphicOn_ratlPolynomial₃U d U).meromorphicOn.divisor = d := by
+
+  funext z
+  rw [MeromorphicOn.divisor]
+  simp
+  by_cases hz : z ∈ U
+  · simp [hz]
+    rw [stronglyMeromorphicOn_divisor_ratlPolynomial₁ d h₁d]
+    simp
+  · simp [hz]
+    rw [eq_comm, ← Function.nmem_support]
+    tauto

Nevanlinna/stronglyMeromorphic_JensenFormula.lean

@@ -0,0 +1,438 @@
+import Nevanlinna.specialFunctions_CircleIntegral_affine
+import Nevanlinna.stronglyMeromorphicOn_eliminate
+
+open Real
+
+theorem jensen₀
+  {R : ℝ}
+  (hR : 0 < R)
+  (f : ℂ → ℂ)
+  -- WARNING: Not needed. MeromorphicOn suffices
+  (h₁f : StronglyMeromorphicOn f (Metric.closedBall 0 R))
+  (h₂f : f 0 ≠ 0) :
+  log ‖f 0‖ = -∑ᶠ s, (h₁f.meromorphicOn.divisor s) * log (R * ‖s‖⁻¹) + (2 * π)⁻¹ * ∫ (x : ℝ) in (0)..(2 * π), log ‖f (circleMap 0 R x)‖ := by
+
+  have h₁U : IsConnected (Metric.closedBall (0 : ℂ) R) := by
+    constructor
+    · apply Metric.nonempty_closedBall.mpr
+      exact le_of_lt hR
+    · exact (convex_closedBall (0 : ℂ) R).isPreconnected
+
+  have h₂U : IsCompact (Metric.closedBall (0 : ℂ) R) :=
+    isCompact_closedBall 0 R
+
+  have h'₂f : ∃ u : (Metric.closedBall (0 : ℂ) R), f u ≠ 0 := by
+    use ⟨0, Metric.mem_closedBall_self (le_of_lt hR)⟩
+
+  have h'₁f : StronglyMeromorphicAt f 0 := by
+    apply h₁f
+    simp
+    exact le_of_lt hR
+
+  have h''₂f : h'₁f.meromorphicAt.order = 0 := by
+    rwa [h'₁f.order_eq_zero_iff]
+
+  have h'''₂f : h₁f.meromorphicOn.divisor 0 = 0 := by
+    unfold MeromorphicOn.divisor
+    simp
+    tauto
+
+  have h₃f : Set.Finite (Function.support h₁f.meromorphicOn.divisor) := by
+    exact Divisor.finiteSupport h₂U (StronglyMeromorphicOn.meromorphicOn h₁f).divisor
+
+  have h'₃f : ∀ s ∈ h₃f.toFinset, s ≠ 0 := by
+    by_contra hCon
+    push_neg at hCon
+    obtain ⟨s, h₁s, h₂s⟩ := hCon
+    rw [h₂s] at h₁s
+    simp at h₁s
+    tauto
+
+  have h₄f: Function.support (fun s ↦ (h₁f.meromorphicOn.divisor s) * log (R * ‖s‖⁻¹)) ⊆ h₃f.toFinset := by
+    intro x
+    contrapose
+    simp
+    intro hx
+    rw [hx]
+    simp
+  rw [finsum_eq_sum_of_support_subset _ h₄f]
+
+  obtain ⟨F, h₁F, h₂F, h₃F, h₄F⟩ := MeromorphicOn.decompose₃' h₂U h₁U h₁f h'₂f
+
+  have h₁F : Function.mulSupport (fun u ↦ fun z => (z - u) ^ (h₁f.meromorphicOn.divisor u)) ⊆ h₃f.toFinset := by
+    intro u
+    contrapose
+    simp
+    intro hu
+    rw [hu]
+    simp
+    exact rfl
+  rw [finprod_eq_prod_of_mulSupport_subset _ h₁F] at h₄F
+
+  let G := fun z ↦ log ‖F z‖ + ∑ᶠ s, (h₁f.meromorphicOn.divisor s) * log ‖z - s‖
+
+  have h₁G {z : ℂ} : Function.support (fun s ↦ (h₁f.meromorphicOn.divisor s) * log ‖z - s‖) ⊆ h₃f.toFinset := by
+    intro s
+    contrapose
+    simp
+    intro hs
+    rw [hs]
+    simp
+
+  have decompose_f : ∀ z ∈ Metric.closedBall (0 : ℂ) R, f z ≠ 0 → log ‖f z‖ = G z := by
+    intro z h₁z h₂z
+
+    rw [h₄F]
+    simp only [Pi.mul_apply, norm_mul]
+    simp only [Finset.prod_apply, norm_prod, norm_zpow]
+    rw [Real.log_mul]
+    rw [Real.log_prod]
+    simp_rw [Real.log_zpow]
+    dsimp only [G]
+    rw [finsum_eq_sum_of_support_subset _ h₁G]
+    --
+    intro x hx
+    have : z ≠ x := by
+      by_contra hCon
+      rw [← hCon] at hx
+      simp at hx
+      rw [← (h₁f z h₁z).order_eq_zero_iff] at h₂z
+      unfold MeromorphicOn.divisor at hx
+      simp [h₁z] at hx
+      tauto
+    apply zpow_ne_zero
+    simpa
+    -- Complex.abs (F z) ≠ 0
+    simp
+    exact h₃F ⟨z, h₁z⟩
+    --
+    rw [Finset.prod_ne_zero_iff]
+    intro x hx
+    have : z ≠ x := by
+      by_contra hCon
+      rw [← hCon] at hx
+      simp at hx
+      rw [← (h₁f z h₁z).order_eq_zero_iff] at h₂z
+      unfold MeromorphicOn.divisor at hx
+      simp [h₁z] at hx
+      tauto
+    apply zpow_ne_zero
+    simpa
+
+
+  have int_logAbs_f_eq_int_G : ∫ (x : ℝ) in (0)..2 * π, log ‖f (circleMap 0 R x)‖ = ∫ (x : ℝ) in (0)..2 * π, G (circleMap 0 R x) := by
+
+    rw [intervalIntegral.integral_congr_ae]
+    rw [MeasureTheory.ae_iff]
+    apply Set.Countable.measure_zero
+    simp
+
+    have t₀ : {a | a ∈ Ι 0 (2 * π) ∧ ¬log ‖f (circleMap 0 R a)‖ = G (circleMap 0 R a)}
+      ⊆ (circleMap 0 R)⁻¹' (h₃f.toFinset) := by
+      intro a ha
+      simp at ha
+      simp
+      by_contra C
+      have t₀ : (circleMap 0 R a) ∈ Metric.closedBall 0 R := by
+        apply circleMap_mem_closedBall
+        exact le_of_lt hR
+      have t₁ : f (circleMap 0 R a) ≠ 0 := by
+        let A := h₁f (circleMap 0 R a) t₀
+        rw [← A.order_eq_zero_iff]
+        unfold MeromorphicOn.divisor at C
+        simp [t₀] at C
+        rcases C with C₁|C₂
+        · assumption
+        · let B := h₁f.meromorphicOn.order_ne_top' h₁U
+          let C := fun q ↦ B.1 q ⟨(circleMap 0 R a), t₀⟩
+          rw [C₂] at C
+          have : ∃ u : (Metric.closedBall (0 : ℂ) R), (h₁f u u.2).meromorphicAt.order ≠ ⊤ := by
+            use ⟨(0 : ℂ), (by simp; exact le_of_lt hR)⟩
+            let H := h₁f 0 (by simp; exact le_of_lt hR)
+            let K := H.order_eq_zero_iff.2 h₂f
+            rw [K]
+            simp
+          let D := C this
+          tauto
+      exact ha.2 (decompose_f (circleMap 0 R a) t₀ t₁)
+
+    apply Set.Countable.mono t₀
+    apply Set.Countable.preimage_circleMap
+    apply Set.Finite.countable
+    exact Finset.finite_toSet h₃f.toFinset
+    --
+    exact Ne.symm (ne_of_lt hR)
+
+
+  have decompose_int_G : ∫ (x : ℝ) in (0)..2 * π, G (circleMap 0 R x)
+    = (∫ (x : ℝ) in (0)..2 * π, log (Complex.abs (F (circleMap 0 R x))))
+        + ∑ᶠ x, (h₁f.meromorphicOn.divisor x) * ∫ (x_1 : ℝ) in (0)..2 * π, log (Complex.abs (circleMap 0 R x_1 - ↑x)) := by
+    dsimp [G]
+
+    rw [intervalIntegral.integral_add]
+    congr
+    have t₀ {x : ℝ} : Function.support (fun s ↦ (h₁f.meromorphicOn.divisor s) * log (Complex.abs (circleMap 0 R x - s))) ⊆ h₃f.toFinset := by
+      intro s hs
+      simp at hs
+      simp [hs.1]
+    conv =>
+      left
+      arg 1
+      intro x
+      rw [finsum_eq_sum_of_support_subset _ t₀]
+    rw [intervalIntegral.integral_finset_sum]
+    let G' := fun x ↦ ((h₁f.meromorphicOn.divisor x) : ℂ) * ∫ (x_1 : ℝ) in (0)..2 * π, log (Complex.abs (circleMap 0 R x_1 - x))
+    have t₁ : (Function.support fun x ↦ (h₁f.meromorphicOn.divisor x) * ∫ (x_1 : ℝ) in (0)..2 * π, log (Complex.abs (circleMap 0 R x_1 - x))) ⊆ h₃f.toFinset := by
+      simp
+      intro s
+      contrapose!
+      simp
+      tauto
+    conv =>
+      right
+      rw [finsum_eq_sum_of_support_subset _ t₁]
+    simp
+
+    --  ∀ i ∈ (finiteZeros h₁U h₂U h'₁f h'₂f).toFinset,
+    --  IntervalIntegrable (fun x => (h'₁f.order i).toNat *
+    --    log (Complex.abs (circleMap 0 1 x - ↑i))) MeasureTheory.volume 0 (2 * π)
+    intro i _
+    apply IntervalIntegrable.const_mul
+    apply intervalIntegrable_logAbs_circleMap_sub_const
+    linarith
+    --
+    -- case neg
+    apply Continuous.intervalIntegrable
+    apply continuous_iff_continuousAt.2
+    intro x
+    have : (fun x => log (Complex.abs ( F (circleMap 0 R x)))) = log ∘ Complex.abs ∘ F ∘ circleMap 0 R :=
+      rfl
+    rw [this]
+    apply ContinuousAt.comp
+    apply Real.continuousAt_log
+    simp
+    let A := h₃F ⟨(circleMap 0 R x), circleMap_mem_closedBall 0 (le_of_lt hR) x⟩
+    exact A
+    --
+    apply ContinuousAt.comp
+    apply Complex.continuous_abs.continuousAt
+    apply ContinuousAt.comp
+    let A := h₂F (circleMap 0 R x) (circleMap_mem_closedBall 0 (le_of_lt hR) x)
+    apply A.continuousAt
+    exact (continuous_circleMap 0 R).continuousAt
+    -- IntervalIntegrable (fun x => ∑ᶠ (s : ℂ), ↑(↑⋯.divisor s) * log (Complex.abs (circleMap 0 1 x - s))) MeasureTheory.volume 0 (2 * π)
+    --simp? at h₁G
+    have h₁G' {z : ℂ} : (Function.support fun s => (h₁f.meromorphicOn.divisor s) * log (Complex.abs (z - s))) ⊆ ↑h₃f.toFinset := by
+      exact h₁G
+    conv =>
+      arg 1
+      intro z
+      rw [finsum_eq_sum_of_support_subset _ h₁G']
+    conv =>
+      arg 1
+      rw [← Finset.sum_fn]
+    apply IntervalIntegrable.sum
+    intro i _
+    apply IntervalIntegrable.const_mul
+    --have : i.1 ∈ Metric.closedBall (0 : ℂ) 1 := i.2
+    --simp at this
+    by_cases h₂i : ‖i‖ = R
+    -- case pos
+    --exact int'₂ h₂i
+    apply intervalIntegrable_logAbs_circleMap_sub_const (Ne.symm (ne_of_lt hR))
+    -- case neg
+    apply Continuous.intervalIntegrable
+    apply continuous_iff_continuousAt.2
+    intro x
+    have : (fun x => log (Complex.abs (circleMap 0 R x - ↑i))) = log ∘ Complex.abs ∘ (fun x ↦ circleMap 0 R x - ↑i) :=
+      rfl
+    rw [this]
+    apply ContinuousAt.comp
+    apply Real.continuousAt_log
+    simp
+
+    by_contra ha'
+    conv at h₂i =>
+      arg 1
+      rw [← ha']
+      rw [Complex.norm_eq_abs]
+      rw [abs_circleMap_zero R x]
+      simp
+    linarith
+    apply ContinuousAt.comp
+    apply Complex.continuous_abs.continuousAt
+    fun_prop
+
+  have t₁ : (∫ (x : ℝ) in (0)..2 * Real.pi, log ‖F (circleMap 0 R x)‖) = 2 * Real.pi * log ‖F 0‖ := by
+    let logAbsF := fun w ↦ Real.log ‖F w‖
+    have t₀ : ∀ z ∈ Metric.closedBall 0 R, HarmonicAt logAbsF z := by
+      intro z hz
+      apply logabs_of_holomorphicAt_is_harmonic
+      exact AnalyticAt.holomorphicAt (h₂F z hz)
+      exact h₃F ⟨z, hz⟩
+
+    apply harmonic_meanValue₁ R hR t₀
+
+
+  simp_rw [← Complex.norm_eq_abs] at decompose_int_G
+  rw [t₁] at decompose_int_G
+
+
+  have h₁G' : (Function.support fun s => (h₁f.meromorphicOn.divisor s) * ∫ (x_1 : ℝ) in (0)..(2 * π), log ‖circleMap 0 R x_1 - s‖) ⊆ ↑h₃f.toFinset := by
+    intro s hs
+    simp at hs
+    simp [hs.1]
+  rw [finsum_eq_sum_of_support_subset _ h₁G'] at decompose_int_G
+  have : ∑ s ∈ h₃f.toFinset, (h₁f.meromorphicOn.divisor s) * ∫ (x_1 : ℝ) in (0)..(2 * π), log ‖circleMap 0 R x_1 - s‖ = ∑ s ∈ h₃f.toFinset, (h₁f.meromorphicOn.divisor s) * (2 * π) * log R := by
+    apply Finset.sum_congr rfl
+    intro s hs
+    have : s ∈ Metric.closedBall 0 R := by
+      let A := h₁f.meromorphicOn.divisor.supportInU
+      have : s ∈ Function.support h₁f.meromorphicOn.divisor := by
+        simp at hs
+        exact hs
+      exact A this
+    rw [int₄ hR this]
+    linarith
+  rw [this] at decompose_int_G
+
+
+  simp at decompose_int_G
+
+  rw [int_logAbs_f_eq_int_G]
+  rw [decompose_int_G]
+  let X := h₄F
+  nth_rw 1 [h₄F]
+  simp
+  have : π⁻¹ * 2⁻¹ * (2 * π) = 1 := by
+    calc π⁻¹ * 2⁻¹ * (2 * π)
+    _ = π⁻¹ * (2⁻¹ * 2) * π := by ring
+    _ = π⁻¹ * π := by ring
+    _ = (π⁻¹ * π) := by ring
+    _ = 1 := by
+      rw [inv_mul_cancel₀]
+      exact pi_ne_zero
+  --rw [this]
+  rw [log_mul]
+  rw [log_prod]
+  simp
+  rw [add_comm]
+  rw [mul_add]
+  rw [← mul_assoc (π⁻¹ * 2⁻¹), this]
+  simp
+  rw [add_comm]
+  nth_rw 2 [add_comm]
+  rw [add_assoc]
+  congr
+  rw [Finset.mul_sum]
+  rw [← sub_eq_add_neg]
+  rw [← Finset.sum_sub_distrib]
+  rw [Finset.sum_congr rfl]
+  intro s hs
+  rw [log_mul, log_inv]
+  rw [← mul_assoc (π⁻¹ * 2⁻¹)]
+  rw [mul_comm _ (2 * π)]
+  rw [← mul_assoc (π⁻¹ * 2⁻¹)]
+  rw [this]
+  simp
+  rw [mul_add]
+  ring
+  --
+  exact Ne.symm (ne_of_lt hR)
+  --
+  simp
+  by_contra hCon
+  rw [hCon] at hs
+  simp at hs
+  exact hs h'''₂f
+  --
+  intro s hs
+  apply zpow_ne_zero
+  simp
+  by_contra hCon
+  rw [hCon] at hs
+  simp at hs
+  exact hs h'''₂f
+  --
+  simp only [ne_eq, map_eq_zero]
+  rw [← ne_eq]
+  exact h₃F ⟨0, (by simp; exact le_of_lt hR)⟩
+  --
+  rw [Finset.prod_ne_zero_iff]
+  intro s hs
+  apply zpow_ne_zero
+  simp
+  by_contra hCon
+  rw [hCon] at hs
+  simp at hs
+  exact hs h'''₂f
+
+
+theorem jensen
+  {R : ℝ}
+  (hR : 0 < R)
+  (f : ℂ → ℂ)
+  (h₁f : MeromorphicOn f (Metric.closedBall 0 R))
+  (h₁f' : StronglyMeromorphicAt f 0)
+  (h₂f : f 0 ≠ 0) :
+  log ‖f 0‖ = -∑ᶠ s, (h₁f.divisor s) * log (R * ‖s‖⁻¹) + (2 * π)⁻¹ * ∫ (x : ℝ) in (0)..(2 * π), log ‖f (circleMap 0 R x)‖ := by
+
+  let F := h₁f.makeStronglyMeromorphicOn
+
+  have : F 0 = f 0 := by
+    unfold F
+    have : 0 ∈ (Metric.closedBall 0 R) := by
+      simp [hR]
+      exact le_of_lt hR
+    unfold MeromorphicOn.makeStronglyMeromorphicOn
+    simp [this]
+    intro h₁R
+
+    let A := StronglyMeromorphicAt.makeStronglyMeromorphic_id h₁f'
+    simp_rw [A]
+  rw [← this]
+  rw [← this] at h₂f
+  clear this
+
+  have h₁F := stronglyMeromorphicOn_of_makeStronglyMeromorphicOn h₁f
+
+  rw [jensen₀ hR F h₁F h₂f]
+
+  rw [h₁f.divisor_of_makeStronglyMeromorphicOn]
+  congr 2
+  have {x : ℝ} : log ‖F (circleMap 0 R x)‖ = (fun z ↦ log ‖F z‖) (circleMap 0 R x) := by
+    rfl
+  conv =>
+    left
+    arg 1
+    intro x
+    rw [this]
+  have {x : ℝ} : log ‖f (circleMap 0 R x)‖ = (fun z ↦ log ‖f z‖) (circleMap 0 R x) := by
+    rfl
+  conv =>
+    right
+    arg 1
+    intro x
+    rw [this]
+
+  have h'R : R ≠ 0 := by exact Ne.symm (ne_of_lt hR)
+  have hU : Metric.sphere (0 : ℂ) |R| ⊆ (Metric.closedBall (0 : ℂ) R) := by
+    have : R = |R| := by exact Eq.symm (abs_of_pos hR)
+    nth_rw 2 [this]
+    exact Metric.sphere_subset_closedBall
+
+  let A := integral_congr_changeDiscrete h'R hU (f₁ := fun z ↦ log ‖F z‖) (f₂ := fun z ↦ log ‖f z‖)
+  apply A
+  clear A
+
+  rw [Filter.eventuallyEq_iff_exists_mem]
+  have A := makeStronglyMeromorphicOn_changeDiscrete'' h₁f
+  rw [Filter.eventuallyEq_iff_exists_mem] at A
+  obtain ⟨s, h₁s, h₂s⟩ := A
+  use s
+  constructor
+  · exact h₁s
+  · intro x hx
+    let A := h₂s hx
+    simp
+    rw [A]

README.md

@@ -0,0 +1,69 @@
+# Project VD
+
+### Formalizing Value Distribution Theory
+
+This project aims to formalize [value distribution
+theory](https://en.wikipedia.org/wiki/Value_distribution_theory_of_holomorphic_functions)
+for meromorphic functions in the complex plane, roughly following Serge Lang's
+[Introduction to Complex Hyperbolic
+Spaces](https://link.springer.com/book/10.1007/978-1-4757-1945-1). The project
+uses the [Lean](https://lean-lang.org/) theorem prover and builds on
+[mathlib](https://leanprover-community.github.io/), the Lean mathematical
+library.
+
+### Help Wanted
+
+Please be in touch if you would like to join
+the fun!
+
+## Current State and Future Plans
+
+With the formalization of Nevanlinna's [First Main
+Theorem](https://en.wikipedia.org/wiki/Nevanlinna_theory#First_fundamental_theorem),
+the project has recently reached its first milestone. The current code has
+"proof of concept" quality: It compiles fine but needs refactoring and
+documentation. Next goals:
+
+- Clean up the existing codebase and feed intermediate results into mathlib
+- Formalize the Theorem on Logarithmic Differentials
+- Formalize the [Second Main
+  Theorem](https://en.wikipedia.org/wiki/Nevanlinna_theory#Second_fundamental_theorem)
+- Establish some of the more immediate applications
+
+These plans might change, depending on feedback from the community and specific
+interests of project participants.
+
+## Material Covered
+
+The following concepts have been formalized so far.
+
+- Harmonic functions in the complex plane
+    - Laplace operator and associated API
+    - Definition and elementary properties of harmonic functions
+    - Mean value properties of harmonic functions
+    - Real and imaginary parts of holomorphic functions as examples of harmonic
+      functions
+- Holomorphic functions in the complex plane
+    - Existence of primitives [duplication of work [already under
+      review](https://github.com/leanprover-community/mathlib4/pull/9598) at
+      mathlib]
+    - Existence of holomorphic functions with given real part
+- Meromorphic Functions in the complex plane
+    - API for continuous extension of meromorphic functions, normal form of
+      meromorphic functions up to changes along a discrete set
+    - Behavior of pole/zero orders under standard operations
+    - Zero/pole divisors attached to meromorphic functions and associated API
+    - Extraction of zeros and poles
+- Integrals and integrability of special functions
+    - Interval integrals and integrability of the logarithm and its combinations
+      with trigonometric functions; circle integrability of log ‖z-a‖
+    - Circle integrability of log ‖meromorphic‖
+- Basic functions of Value Distribution Theory
+    - The positive part of the logarithm, API, standard inequalities and
+      estimates
+    - Logarithmic counting functions of divisors
+    - Nevanlinna heights of entire meromorphic functions
+    - Proximity functions for entire meromorphic functions
+- [Jensen's formula](https://en.wikipedia.org/wiki/Jensen%27s_formula)
+- Nevanlinna's [First Main
+  Theorem](https://en.wikipedia.org/wiki/Nevanlinna_theory#First_fundamental_theorem)

lake-manifest.json

@@ -1,52 +1,32 @@
 {"version": "1.1.0",
  "packagesDir": ".lake/packages",
  "packages":
- [{"url": "https://github.com/leanprover-community/batteries",
+ [{"url": "https://github.com/leanprover-community/mathlib4.git",
+   "type": "git",
+   "subDir": null,
+   "scope": "",
+   "rev": "0571c82877b7c2b508cbc9a39e041eb117d050b7",
+   "name": "mathlib",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": null,
+   "inherited": false,
+   "configFile": "lakefile.lean"},
+  {"url": "https://github.com/leanprover-community/plausible",
    "type": "git",
    "subDir": null,
    "scope": "leanprover-community",
-   "rev": "500a529408399c44d7e1649577e3c98697f95aa4",
-   "name": "batteries",
+   "rev": "8e5cb8d424df462f84997dd68af6f40e347c3e35",
+   "name": "plausible",
    "manifestFile": "lake-manifest.json",
-   "inputRev": "main",
+   "inputRev": "v4.15.0-rc1",
    "inherited": true,
    "configFile": "lakefile.toml"},
-  {"url": "https://github.com/leanprover-community/quote4",
+  {"url": "https://github.com/leanprover-community/LeanSearchClient",
    "type": "git",
    "subDir": null,
    "scope": "leanprover-community",
-   "rev": "1357f4f49450abb9dfd4783e38219f4ce84f9785",
-   "name": "Qq",
-   "manifestFile": "lake-manifest.json",
-   "inputRev": "master",
-   "inherited": true,
-   "configFile": "lakefile.lean"},
-  {"url": "https://github.com/leanprover-community/aesop",
-   "type": "git",
-   "subDir": null,
-   "scope": "leanprover-community",
-   "rev": "9ac12945862fa39eab7795c2f79bb9aa0c8e332c",
-   "name": "aesop",
-   "manifestFile": "lake-manifest.json",
-   "inputRev": "master",
-   "inherited": true,
-   "configFile": "lakefile.toml"},
-  {"url": "https://github.com/leanprover-community/ProofWidgets4",
-   "type": "git",
-   "subDir": null,
-   "scope": "leanprover-community",
-   "rev": "baa65c6339a56bd22b7292aa4511c54b3cc7a6af",
-   "name": "proofwidgets",
-   "manifestFile": "lake-manifest.json",
-   "inputRev": "v0.0.43",
-   "inherited": true,
-   "configFile": "lakefile.lean"},
-  {"url": "https://github.com/leanprover/lean4-cli",
-   "type": "git",
-   "subDir": null,
-   "scope": "leanprover",
-   "rev": "2cf1030dc2ae6b3632c84a09350b675ef3e347d0",
-   "name": "Cli",
+   "rev": "003ff459cdd85de551f4dcf95cdfeefe10f20531",
+   "name": "LeanSearchClient",
    "manifestFile": "lake-manifest.json",
    "inputRev": "main",
    "inherited": true,
@@ -55,31 +35,61 @@
    "type": "git",
    "subDir": null,
    "scope": "leanprover-community",
-   "rev": "c1970bea80ac3357a6a991a6d00d12e7435c12c7",
+   "rev": "ed3b856bd8893ade75cafe13e8544d4c2660f377",
    "name": "importGraph",
    "manifestFile": "lake-manifest.json",
-   "inputRev": "main",
+   "inputRev": "v4.15.0-rc1",
    "inherited": true,
    "configFile": "lakefile.toml"},
-  {"url": "https://github.com/leanprover-community/LeanSearchClient",
+  {"url": "https://github.com/leanprover-community/ProofWidgets4",
    "type": "git",
    "subDir": null,
    "scope": "leanprover-community",
-   "rev": "7bedaed1ef024add1e171cc17706b012a9a37802",
-   "name": "LeanSearchClient",
+   "rev": "2b000e02d50394af68cfb4770a291113d94801b5",
+   "name": "proofwidgets",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "v0.0.48",
+   "inherited": true,
+   "configFile": "lakefile.lean"},
+  {"url": "https://github.com/leanprover-community/aesop",
+   "type": "git",
+   "subDir": null,
+   "scope": "leanprover-community",
+   "rev": "a4a08d92be3de00def5298059bf707c72dfd3c66",
+   "name": "aesop",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "master",
+   "inherited": true,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/leanprover-community/quote4",
+   "type": "git",
+   "subDir": null,
+   "scope": "leanprover-community",
+   "rev": "ad942fdf0b15c38bface6acbb01d63855a2519ac",
+   "name": "Qq",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "v4.14.0",
+   "inherited": true,
+   "configFile": "lakefile.lean"},
+  {"url": "https://github.com/leanprover-community/batteries",
+   "type": "git",
+   "subDir": null,
+   "scope": "leanprover-community",
+   "rev": "f007bfe46ea8fb801ec907df9ab540054abcc5fd",
+   "name": "batteries",
    "manifestFile": "lake-manifest.json",
    "inputRev": "main",
    "inherited": true,
    "configFile": "lakefile.toml"},
-  {"url": "https://github.com/leanprover-community/mathlib4.git",
+  {"url": "https://github.com/leanprover/lean4-cli",
    "type": "git",
    "subDir": null,
-   "scope": "",
-   "rev": "d9273054fe5aee13954cca827d9bbfe7a01bde67",
-   "name": "mathlib",
+   "scope": "leanprover",
+   "rev": "0c8ea32a15a4f74143e4e1e107ba2c412adb90fd",
+   "name": "Cli",
    "manifestFile": "lake-manifest.json",
-   "inputRev": null,
-   "inherited": false,
-   "configFile": "lakefile.lean"}],
+   "inputRev": "main",
+   "inherited": true,
+   "configFile": "lakefile.toml"}],
  "name": "nevanlinna",
  "lakeDir": ".lake"}

lean-toolchain

@@ -1 +1 @@
-leanprover/lean4:v4.13.0-rc3
+leanprover/lean4:v4.15.0-rc1