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

@@ -0,0 +1,344 @@
+import Mathlib.Analysis.Analytic.IsolatedZeros
+import Mathlib.Analysis.Complex.Basic
+import Mathlib.Analysis.Analytic.Linear
+
+open Topology
+
+
+theorem AnalyticAt.order_neq_top_iff
+  {f : ℂ → ℂ}
+  {z₀ : ℂ}
+  (hf : AnalyticAt ℂ f z₀) :
+  hf.order ≠ ⊤ ↔ ∃ (g : ℂ → ℂ), AnalyticAt ℂ g z₀ ∧ g z₀ ≠ 0 ∧ ∀ᶠ (z : ℂ) in nhds z₀, f z = (z - z₀) ^ (hf.order.toNat) • g z := by
+  rw [← hf.order_eq_nat_iff]
+  constructor
+  · intro h₁f
+    exact Eq.symm (ENat.coe_toNat h₁f)
+  · intro h₁f
+    exact ENat.coe_toNat_eq_self.mp (id (Eq.symm h₁f))
+
+
+theorem AnalyticAt.order_mul
+  {f₁ f₂ : ℂ → ℂ}
+  {z₀ : ℂ}
+  (hf₁ : AnalyticAt ℂ f₁ z₀)
+  (hf₂ : AnalyticAt ℂ f₂ z₀) :
+  (hf₁.mul hf₂).order = hf₁.order + hf₂.order := by
+  by_cases h₂f₁ : hf₁.order = ⊤
+  · simp [h₂f₁]
+    rw [AnalyticAt.order_eq_top_iff, eventually_nhds_iff]
+    rw [AnalyticAt.order_eq_top_iff, eventually_nhds_iff] at h₂f₁
+    obtain ⟨t, h₁t, h₂t, h₃t⟩ := h₂f₁
+    use t
+    constructor
+    · intro y hy
+      rw [h₁t y hy]
+      ring
+    · exact ⟨h₂t, h₃t⟩
+  · by_cases h₂f₂ : hf₂.order = ⊤
+    · simp [h₂f₂]
+      rw [AnalyticAt.order_eq_top_iff, eventually_nhds_iff]
+      rw [AnalyticAt.order_eq_top_iff, eventually_nhds_iff] at h₂f₂
+      obtain ⟨t, h₁t, h₂t, h₃t⟩ := h₂f₂
+      use t
+      constructor
+      · intro y hy
+        rw [h₁t y hy]
+        ring
+      · exact ⟨h₂t, h₃t⟩
+    · obtain ⟨g₁, h₁g₁, h₂g₁, h₃g₁⟩ := (AnalyticAt.order_eq_nat_iff hf₁ ↑hf₁.order.toNat).1 (eq_comm.1 (ENat.coe_toNat h₂f₁))
+      obtain ⟨g₂, h₁g₂, h₂g₂, h₃g₂⟩ := (AnalyticAt.order_eq_nat_iff hf₂ ↑hf₂.order.toNat).1 (eq_comm.1 (ENat.coe_toNat h₂f₂))
+      rw [← ENat.coe_toNat h₂f₁, ← ENat.coe_toNat h₂f₂, ← ENat.coe_add]
+      rw [AnalyticAt.order_eq_nat_iff (AnalyticAt.mul hf₁ hf₂) ↑(hf₁.order.toNat + hf₂.order.toNat)]
+      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 h₃g₁
+          obtain ⟨t₂, h₁t₂, h₂t₂, h₃t₂⟩ := eventually_nhds_iff.1 h₃g₂
+          rw [eventually_nhds_iff]
+          use t₁ ∩ t₂
+          constructor
+          · intro y hy
+            rw [h₁t₁ y hy.1, h₁t₂ y hy.2]
+            simp; ring
+          · constructor
+            · exact IsOpen.inter h₂t₁ h₂t₂
+            · exact Set.mem_inter h₃t₁ h₃t₂
+
+
+theorem AnalyticAt.order_eq_zero_iff
+  {f : ℂ → ℂ}
+  {z₀ : ℂ}
+  (hf : AnalyticAt ℂ f z₀) :
+  hf.order = 0 ↔ f z₀ ≠ 0 := by
+
+  have : (0 : ENat) = (0 : Nat) := by rfl
+  rw [this, AnalyticAt.order_eq_nat_iff hf 0]
+
+  constructor
+  · intro hz
+    obtain ⟨g, _, h₂g, h₃g⟩ := hz
+    simp at h₃g
+    rw [Filter.Eventually.self_of_nhds h₃g]
+    tauto
+  · intro hz
+    use f
+    constructor
+    · exact hf
+    · constructor
+      · exact hz
+      · simp
+
+
+theorem AnalyticAt.order_pow
+  {f : ℂ → ℂ}
+  {z₀ : ℂ}
+  {n : ℕ}
+  (hf : AnalyticAt ℂ f z₀) :
+  (hf.pow n).order = n * hf.order := by
+
+  induction' n with n hn
+  · simp; rw [AnalyticAt.order_eq_zero_iff]; simp
+  · simp
+    simp_rw [add_mul, pow_add]
+    simp
+    rw [AnalyticAt.order_mul (hf.pow n) hf]
+    rw [hn]
+
+
+theorem AnalyticAt.supp_order_toNat
+  {f : ℂ → ℂ}
+  {z₀ : ℂ}
+  (hf : AnalyticAt ℂ f z₀) :
+  hf.order.toNat ≠ 0 → f z₀ = 0 := by
+
+  contrapose
+  intro h₁f
+  simp [hf.order_eq_zero_iff.2 h₁f]
+
+
+theorem eventually_nhds_comp_composition
+  {f₁ f₂ ℓ : ℂ → ℂ}
+  {z₀ : ℂ}
+  (hf : ∀ᶠ (z : ℂ) in nhds (ℓ z₀), f₁ z = f₂ z)
+  (hℓ : Continuous ℓ) :
+  ∀ᶠ (z : ℂ) in nhds z₀, (f₁ ∘ ℓ) z = (f₂ ∘ ℓ) z := by
+  obtain ⟨t, h₁t, h₂t, h₃t⟩ := eventually_nhds_iff.1 hf
+  apply eventually_nhds_iff.2
+  use ℓ⁻¹' t
+  constructor
+  · intro y hy
+    exact h₁t (ℓ y) hy
+  · constructor
+    · apply IsOpen.preimage
+      exact hℓ
+      exact h₂t
+    · exact h₃t
+
+
+theorem AnalyticAt.order_congr
+  {f₁ f₂ : ℂ → ℂ}
+  {z₀ : ℂ}
+  (hf₁ : AnalyticAt ℂ f₁ z₀)
+  (hf : f₁ =ᶠ[nhds z₀] f₂) :
+  hf₁.order = (hf₁.congr hf).order := by
+
+  by_cases h₁f₁ : hf₁.order = ⊤
+  rw [h₁f₁, eq_comm, AnalyticAt.order_eq_top_iff]
+  rw [AnalyticAt.order_eq_top_iff] at h₁f₁
+  exact Filter.EventuallyEq.rw h₁f₁ (fun x => Eq (f₂ x)) (id (Filter.EventuallyEq.symm hf))
+  --
+  let n := hf₁.order.toNat
+  have hn : hf₁.order = n := Eq.symm (ENat.coe_toNat h₁f₁)
+  rw [hn, eq_comm, AnalyticAt.order_eq_nat_iff]
+  rw [AnalyticAt.order_eq_nat_iff] at hn
+  obtain ⟨g, h₁g, h₂g, h₃g⟩ := hn
+  use g
+  constructor
+  · assumption
+  · constructor
+    · assumption
+    · exact Filter.EventuallyEq.rw h₃g (fun x => Eq (f₂ x)) (id (Filter.EventuallyEq.symm hf))
+
+
+theorem AnalyticAt.order_comp_CLE
+  (ℓ : ℂ ≃L[ℂ] ℂ)
+  {f : ℂ → ℂ}
+  {z₀ : ℂ}
+  (hf : AnalyticAt ℂ f (ℓ z₀)) :
+  hf.order = (hf.comp (ℓ.analyticAt z₀)).order := by
+
+  by_cases h₁f : hf.order = ⊤
+  · rw [h₁f]
+    rw [AnalyticAt.order_eq_top_iff] at h₁f
+    let A := eventually_nhds_comp_composition h₁f ℓ.continuous
+    simp at A
+    rw [AnalyticAt.order_congr (hf.comp (ℓ.analyticAt z₀)) A]
+
+    have : AnalyticAt ℂ (0 : ℂ → ℂ) z₀ := by
+      apply analyticAt_const
+    have : this.order = ⊤ := by
+      rw [AnalyticAt.order_eq_top_iff]
+      simp
+    rw [this]
+  · let n := hf.order.toNat
+    have hn : hf.order = n := Eq.symm (ENat.coe_toNat h₁f)
+    rw [hn]
+    rw [AnalyticAt.order_eq_nat_iff] at hn
+    obtain ⟨g, h₁g, h₂g, h₃g⟩ := hn
+    have A := eventually_nhds_comp_composition h₃g ℓ.continuous
+
+    have t₁ : AnalyticAt ℂ (fun z => ℓ z - ℓ z₀) z₀ := by
+      apply AnalyticAt.sub
+      exact ContinuousLinearEquiv.analyticAt ℓ z₀
+      exact analyticAt_const
+    have t₀ : AnalyticAt ℂ (fun z => (ℓ z - ℓ z₀) ^ n) z₀ := by
+      exact pow t₁ n
+    have : AnalyticAt ℂ (fun z ↦ (ℓ z - ℓ z₀) ^ n • g (ℓ z) : ℂ → ℂ) z₀ := by
+      apply AnalyticAt.mul
+      exact t₀
+      apply AnalyticAt.comp h₁g
+      exact ContinuousLinearEquiv.analyticAt ℓ z₀
+    rw [AnalyticAt.order_congr (hf.comp (ℓ.analyticAt z₀)) A]
+    simp
+
+    rw [AnalyticAt.order_mul t₀ ((h₁g.comp (ℓ.analyticAt z₀)))]
+
+    have : t₁.order = (1 : ℕ) := by
+      rw [AnalyticAt.order_eq_nat_iff]
+      use (fun _ ↦ ℓ 1)
+      simp
+      constructor
+      · exact analyticAt_const
+      · apply Filter.Eventually.of_forall
+        intro x
+        calc ℓ x - ℓ z₀
+        _ = ℓ (x - z₀) := by
+          exact Eq.symm (ContinuousLinearEquiv.map_sub ℓ x z₀)
+        _ = ℓ ((x - z₀) * 1) := by
+          simp
+        _ = (x - z₀) * ℓ 1 := by
+          rw [← smul_eq_mul, ← smul_eq_mul]
+          exact ContinuousLinearEquiv.map_smul ℓ (x - z₀) 1
+
+    have : t₀.order = n := by
+      rw [AnalyticAt.order_pow t₁, this]
+      simp
+
+    rw [this]
+
+    have : (comp h₁g (ContinuousLinearEquiv.analyticAt ℓ z₀)).order = 0 := by
+      rwa [AnalyticAt.order_eq_zero_iff]
+    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 ℝ
@@ -44,8 +44,10 @@ theorem CauchyRiemann₃ : (DifferentiableAt ℂ f z)
   simp
 
 
-theorem CauchyRiemann₄ {F : Type*} [NormedAddCommGroup F] [NormedSpace ℂ F] {f : ℂ → F} : (Differentiable ℂ f)
-  → partialDeriv ℝ Complex.I f = Complex.I • partialDeriv ℝ 1 f := by
+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
 
@@ -56,9 +58,27 @@ theorem CauchyRiemann₄ {F : Type*} [NormedAddCommGroup F] [NormedSpace ℂ F]
     simp
     rw [← mul_one Complex.I]
     rw [← smul_eq_mul]
-    rw [ContinuousLinearMap.map_smul_of_tower (fderiv ℂ f w) Complex.I 1]
   conv =>
     right
     right
     intro w
     rw [DifferentiableAt.fderiv_restrictScalars ℝ (h w)]
+  funext w
+  simp
+
+theorem CauchyRiemann₅ {F : Type*} [NormedAddCommGroup F] [NormedSpace ℂ F] {f : ℂ → F} {z : ℂ} : (DifferentiableAt ℂ f z)
+  → partialDeriv ℝ Complex.I f z = Complex.I • partialDeriv ℝ 1 f z := by
+  intro h
+  unfold partialDeriv
+
+  conv =>
+    left
+    rw [DifferentiableAt.fderiv_restrictScalars ℝ h]
+    simp
+    rw [← mul_one Complex.I]
+    rw [← smul_eq_mul]
+  conv =>
+    right
+    right
+    rw [DifferentiableAt.fderiv_restrictScalars ℝ h]
+  simp

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/complexHarmonic.lean

@@ -1,344 +0,0 @@
-import Mathlib.Analysis.Complex.Basic
-import Mathlib.Analysis.Complex.TaylorSeries
-import Mathlib.Analysis.Calculus.LineDeriv.Basic
-import Mathlib.Analysis.Calculus.ContDiff.Defs
-import Mathlib.Analysis.Calculus.FDeriv.Basic
-import Mathlib.Analysis.Calculus.FDeriv.Symmetric
-import Mathlib.Analysis.SpecialFunctions.Complex.LogDeriv
-import Mathlib.Data.Complex.Module
-import Mathlib.Data.Complex.Order
-import Mathlib.Data.Complex.Exponential
-import Mathlib.Data.Fin.Tuple.Basic
-import Mathlib.Analysis.RCLike.Basic
-import Mathlib.Topology.Algebra.InfiniteSum.Module
-import Mathlib.Topology.Instances.RealVectorSpace
-import Nevanlinna.cauchyRiemann
-import Nevanlinna.laplace
-import Nevanlinna.partialDeriv
-
-variable {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F]
-variable {F₁ : Type*} [NormedAddCommGroup F₁] [NormedSpace ℂ F₁] [CompleteSpace F₁]
-variable {G : Type*} [NormedAddCommGroup G] [NormedSpace ℝ G]
-variable {G₁ : Type*} [NormedAddCommGroup G₁] [NormedSpace ℂ G₁] [CompleteSpace G₁]
-
-
-def Harmonic (f : ℂ → F) : Prop :=
-  (ContDiff ℝ 2 f) ∧ (∀ z, Complex.laplace f z = 0)
-
-
-def HarmonicOn (f : ℂ → F) (s : Set ℂ) : Prop :=
-  (ContDiffOn ℝ 2 f s) ∧ (∀ z ∈ s, Complex.laplace f z = 0)
-
-
-theorem HarmonicOn_of_locally_HarmonicOn {f : ℂ → F} {s : Set ℂ} (h : ∀ x ∈ s, ∃ (u : Set ℂ), IsOpen u ∧ x ∈ u ∧ HarmonicOn f (s ∩ u)) :
-  HarmonicOn f s := by
-  constructor
-  · apply contDiffOn_of_locally_contDiffOn
-    intro x xHyp
-    obtain ⟨u, uHyp⟩  := h x xHyp
-    use u
-    exact ⟨ uHyp.1, ⟨uHyp.2.1, uHyp.2.2.1⟩⟩
-  · intro x xHyp
-    obtain ⟨u, uHyp⟩  := h x xHyp
-    exact (uHyp.2.2.2) x ⟨xHyp, uHyp.2.1⟩
-
-
-theorem harmonic_add_harmonic_is_harmonic {f₁ f₂ : ℂ → F} (h₁ : Harmonic f₁) (h₂ : Harmonic f₂) :
-  Harmonic (f₁ + f₂) := by
-  constructor
-  · exact ContDiff.add h₁.1 h₂.1
-  · rw [laplace_add h₁.1 h₂.1]
-    simp
-    intro z
-    rw [h₁.2 z, h₂.2 z]
-    simp
-
-
-theorem harmonic_smul_const_is_harmonic {f : ℂ → F} {c : ℝ} (h : Harmonic f) :
-  Harmonic (c • f) := by
-  constructor
-  · exact ContDiff.const_smul c h.1
-  · rw [laplace_smul h.1]
-    dsimp
-    intro z
-    rw [h.2 z]
-    simp
-
-
-theorem harmonic_iff_smul_const_is_harmonic {f : ℂ → F} {c : ℝ} (hc : c ≠ 0) :
-  Harmonic f ↔ Harmonic (c • f) := by
-  constructor
-  · exact harmonic_smul_const_is_harmonic
-  · nth_rewrite 2 [((eq_inv_smul_iff₀ hc).mpr rfl : f = c⁻¹ • c • f)]
-    exact fun a => harmonic_smul_const_is_harmonic a
-
-
-theorem harmonic_comp_CLM_is_harmonic {f : ℂ → F₁} {l : F₁ →L[ℝ] G} (h : Harmonic f) :
-  Harmonic (l ∘ f) := by
-
-  constructor
-  · -- Continuous differentiability
-    apply ContDiff.comp
-    exact ContinuousLinearMap.contDiff l
-    exact h.1
-  · rw [laplace_compContLin]
-    simp
-    intro z
-    rw [h.2 z]
-    simp
-    exact ContDiff.restrict_scalars ℝ h.1
-
-
-theorem harmonicOn_comp_CLM_is_harmonicOn {f : ℂ → F₁} {s : Set ℂ} {l : F₁ →L[ℝ] G} (h : HarmonicOn f s) :
-  HarmonicOn (l ∘ f) s := by
-
-  constructor
-  · -- Continuous differentiability
-    apply ContDiffOn.continuousLinearMap_comp
-    exact h.1
-  · -- Vanishing of Laplace
-
-    rw [laplace_compContLin]
-    simp
-    intro z zHyp
-    rw [h.2 z]
-    simp
-    assumption
-
-
-
-
-theorem harmonic_iff_comp_CLE_is_harmonic {f : ℂ → F₁} {l : F₁ ≃L[ℝ] G₁} :
-  Harmonic f ↔ Harmonic (l ∘ f) := by
-
-  constructor
-  · have : l ∘ f = (l : F₁ →L[ℝ] G₁) ∘ f := by rfl
-    rw [this]
-    exact harmonic_comp_CLM_is_harmonic
-  · have : f = (l.symm : G₁ →L[ℝ] F₁) ∘ l ∘ f := by
-      funext z
-      unfold Function.comp
-      simp
-    nth_rewrite 2 [this]
-    exact harmonic_comp_CLM_is_harmonic
-
-
-theorem holomorphic_is_harmonic {f : ℂ → F₁} (h : Differentiable ℂ f) :
-  Harmonic f := by
-
-  -- f is real C²
-  have f_is_real_C2 : ContDiff ℝ 2 f :=
-    ContDiff.restrict_scalars ℝ (Differentiable.contDiff h)
-
-  have fI_is_real_differentiable : Differentiable ℝ (partialDeriv ℝ 1 f) := by
-    exact (partialDeriv_contDiff ℝ f_is_real_C2 1).differentiable (Submonoid.oneLE.proof_2 ℕ∞)
-
-  constructor
-  · -- f is two times real continuously differentiable
-    exact f_is_real_C2
-
-  · -- Laplace of f is zero
-    unfold Complex.laplace
-    rw [CauchyRiemann₄ h]
-
-    -- This lemma says that partial derivatives commute with complex scalar
-    -- multiplication. This is a consequence of partialDeriv_compContLin once we
-    -- note that complex scalar multiplication is continuous ℝ-linear.
-    have : ∀ v, ∀ s : ℂ, ∀ g : ℂ → F₁, Differentiable ℝ g → partialDeriv ℝ v (s • g) = s • (partialDeriv ℝ v g) := by
-      intro v s g hg
-
-      -- Present scalar multiplication as a continuous ℝ-linear map. This is
-      -- horrible, there must be better ways to do that.
-      let sMuls : F₁ →L[ℝ] F₁ :=
-      {
-        toFun := fun x ↦ s • x
-        map_add' := by exact fun x y => DistribSMul.smul_add s x y
-        map_smul' := by exact fun m x => (smul_comm ((RingHom.id ℝ) m) s x).symm
-        cont := continuous_const_smul s
-      }
-
-      -- Bring the goal into a form that is recognized by
-      -- partialDeriv_compContLin.
-      have : s • g = sMuls ∘ g := by rfl
-      rw [this]
-
-      rw [partialDeriv_compContLin ℝ hg]
-      rfl
-
-    rw [this]
-    rw [partialDeriv_comm f_is_real_C2 Complex.I 1]
-    rw [CauchyRiemann₄ h]
-    rw [this]
-    rw [← smul_assoc]
-    simp
-
-    -- Subgoals coming from the application of 'this'
-    -- Differentiable ℝ (Real.partialDeriv 1 f)
-    exact fI_is_real_differentiable
-    -- Differentiable ℝ (Real.partialDeriv 1 f)
-    exact fI_is_real_differentiable
-
-
-theorem re_of_holomorphic_is_harmonic {f : ℂ → ℂ} (h : Differentiable ℂ f) :
-  Harmonic (Complex.reCLM ∘ f) := by
-  apply harmonic_comp_CLM_is_harmonic
-  exact holomorphic_is_harmonic h
-
-
-theorem im_of_holomorphic_is_harmonic {f : ℂ → ℂ} (h : Differentiable ℂ f) :
-  Harmonic (Complex.imCLM ∘ f) := by
-  apply harmonic_comp_CLM_is_harmonic
-  exact holomorphic_is_harmonic h
-
-
-theorem antiholomorphic_is_harmonic {f : ℂ → ℂ} (h : Differentiable ℂ f) :
-  Harmonic (Complex.conjCLE ∘ f) := by
-  apply harmonic_iff_comp_CLE_is_harmonic.1
-  exact holomorphic_is_harmonic h
-
-
-theorem log_normSq_of_holomorphicOn_is_harmonicOn
-  {f : ℂ → ℂ}
-  {s : Set ℂ}
-  (h₁ : DifferentiableOn ℂ f s)
-  (h₂ : ∀ z ∈ s, f z ≠ 0)
-  (h₃ : ∀ z ∈ s, f z ∈ Complex.slitPlane) :
-  HarmonicOn (Real.log ∘ Complex.normSq ∘ f) s := by
-
-  suffices hyp : Harmonic (⇑Complex.ofRealCLM ∘ Real.log ∘ Complex.normSq ∘ f) from
-    (harmonic_comp_CLM_is_harmonic hyp : Harmonic (Complex.reCLM ∘ Complex.ofRealCLM ∘ Real.log ∘ Complex.normSq ∘ f))
-
-  suffices hyp : Harmonic (Complex.log ∘ (((starRingEnd ℂ) ∘ f) * f)) from by
-    have : Complex.ofRealCLM ∘ Real.log ∘ Complex.normSq ∘ f = Complex.log ∘ (((starRingEnd ℂ) ∘ f) * f) := by
-      funext z
-      simp
-      rw [Complex.ofReal_log (Complex.normSq_nonneg (f z))]
-      rw [Complex.normSq_eq_conj_mul_self]
-    rw [this]
-    exact hyp
-
-
-  -- Suffices to show Harmonic (Complex.log ∘ ⇑(starRingEnd ℂ) ∘ f + Complex.log ∘ f)
-  -- THIS IS WHERE WE USE h₃
-  have : Complex.log ∘ (⇑(starRingEnd ℂ) ∘ f * f) = Complex.log ∘ ⇑(starRingEnd ℂ) ∘ f + Complex.log ∘ f := by
-    unfold Function.comp
-    funext z
-    simp
-    rw [Complex.log_mul_eq_add_log_iff]
-
-    have : Complex.arg ((starRingEnd ℂ) (f z)) = - Complex.arg (f z) := by
-      rw [Complex.arg_conj]
-      have : ¬ Complex.arg (f z) = Real.pi := by
-        exact Complex.slitPlane_arg_ne_pi (h₃ z)
-      simp
-      tauto
-    rw [this]
-    simp
-    constructor
-    · exact Real.pi_pos
-    · exact Real.pi_nonneg
-    exact (AddEquivClass.map_ne_zero_iff starRingAut).mpr (h₂ z)
-    exact h₂ z
-  rw [this]
-
-  apply harmonic_add_harmonic_is_harmonic
-  have : Complex.log ∘ ⇑(starRingEnd ℂ) ∘ f = Complex.conjCLE ∘ Complex.log ∘ f := by
-    funext z
-    unfold Function.comp
-    rw [Complex.log_conj]
-    rfl
-    exact Complex.slitPlane_arg_ne_pi (h₃ z)
-  rw [this]
-  rw [← harmonic_iff_comp_CLE_is_harmonic]
-
-  repeat
-    apply holomorphic_is_harmonic
-    intro z
-    apply DifferentiableAt.comp
-    exact Complex.differentiableAt_log (h₃ z)
-    exact h₁ z
-
-
-theorem log_normSq_of_holomorphic_is_harmonic
-  {f : ℂ → ℂ}
-  (h₁ : Differentiable ℂ f)
-  (h₂ : ∀ z, f z ≠ 0)
-  (h₃ : ∀ z, f z ∈ Complex.slitPlane) :
-  Harmonic (Real.log ∘ Complex.normSq ∘ f) := by
-
-  suffices hyp : Harmonic (⇑Complex.ofRealCLM ∘ Real.log ∘ Complex.normSq ∘ f) from
-    (harmonic_comp_CLM_is_harmonic hyp : Harmonic (Complex.reCLM ∘ Complex.ofRealCLM ∘ Real.log ∘ Complex.normSq ∘ f))
-
-  suffices hyp : Harmonic (Complex.log ∘ (((starRingEnd ℂ) ∘ f) * f)) from by
-    have : Complex.ofRealCLM ∘ Real.log ∘ Complex.normSq ∘ f = Complex.log ∘ (((starRingEnd ℂ) ∘ f) * f) := by
-      funext z
-      simp
-      rw [Complex.ofReal_log (Complex.normSq_nonneg (f z))]
-      rw [Complex.normSq_eq_conj_mul_self]
-    rw [this]
-    exact hyp
-
-
-  -- Suffices to show Harmonic (Complex.log ∘ ⇑(starRingEnd ℂ) ∘ f + Complex.log ∘ f)
-  -- THIS IS WHERE WE USE h₃
-  have : Complex.log ∘ (⇑(starRingEnd ℂ) ∘ f * f) = Complex.log ∘ ⇑(starRingEnd ℂ) ∘ f + Complex.log ∘ f := by
-    unfold Function.comp
-    funext z
-    simp
-    rw [Complex.log_mul_eq_add_log_iff]
-
-    have : Complex.arg ((starRingEnd ℂ) (f z)) = - Complex.arg (f z) := by
-      rw [Complex.arg_conj]
-      have : ¬ Complex.arg (f z) = Real.pi := by
-        exact Complex.slitPlane_arg_ne_pi (h₃ z)
-      simp
-      tauto
-    rw [this]
-    simp
-    constructor
-    · exact Real.pi_pos
-    · exact Real.pi_nonneg
-    exact (AddEquivClass.map_ne_zero_iff starRingAut).mpr (h₂ z)
-    exact h₂ z
-  rw [this]
-
-  apply harmonic_add_harmonic_is_harmonic
-  have : Complex.log ∘ ⇑(starRingEnd ℂ) ∘ f = Complex.conjCLE ∘ Complex.log ∘ f := by
-    funext z
-    unfold Function.comp
-    rw [Complex.log_conj]
-    rfl
-    exact Complex.slitPlane_arg_ne_pi (h₃ z)
-  rw [this]
-  rw [← harmonic_iff_comp_CLE_is_harmonic]
-
-  repeat
-    apply holomorphic_is_harmonic
-    intro z
-    apply DifferentiableAt.comp
-    exact Complex.differentiableAt_log (h₃ z)
-    exact h₁ z
-
-
-theorem logabs_of_holomorphic_is_harmonic
-  {f : ℂ → ℂ}
-  (h₁ : Differentiable ℂ f)
-  (h₂ : ∀ z, f z ≠ 0)
-  (h₃ : ∀ z, f z ∈ Complex.slitPlane) :
-  Harmonic (fun z ↦ Real.log ‖f z‖) := by
-
-  -- Suffices: Harmonic (2⁻¹ • Real.log ∘ ⇑Complex.normSq ∘ f)
-  have : (fun z ↦ Real.log ‖f z‖) = (2 : ℝ)⁻¹ • (Real.log ∘ Complex.normSq ∘ f) := by
-    funext z
-    simp
-    unfold Complex.abs
-    simp
-    rw [Real.log_sqrt]
-    rw [div_eq_inv_mul (Real.log (Complex.normSq (f z))) 2]
-    exact Complex.normSq_nonneg (f z)
-  rw [this]
-
-  -- Suffices: Harmonic (Real.log ∘ ⇑Complex.normSq ∘ f)
-  apply (harmonic_iff_smul_const_is_harmonic (inv_ne_zero two_ne_zero)).1
-
-  exact log_normSq_of_holomorphic_is_harmonic h₁ h₂ h₃

Nevanlinna/divisor.lean

@@ -0,0 +1,107 @@
+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
+
+
+structure Divisor
+  (U : Set ℂ)
+  where
+  toFun : ℂ → ℤ
+  supportInU : toFun.support ⊆ U
+  locallyFiniteInU : ∀ x ∈ U, toFun =ᶠ[𝓝[≠] x] 0
+
+instance
+  (U : Set ℂ) :
+  CoeFun (Divisor U) (fun _ ↦ ℂ → ℤ) where
+  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

@@ -0,0 +1,435 @@
+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
+
+
+-- 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 MeromorphicOn.N_infty
+  {f : ℂ → ℂ}
+  (hf : MeromorphicOn f ⊤) :
+  ℝ → ℝ :=
+  fun r ↦ ∑ᶠ z, (max 0 (-((hf.restrict |r|).divisor z))) * log (r * ‖z‖⁻¹)
+
+
+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

@@ -0,0 +1,330 @@
+import Nevanlinna.laplace
+
+variable {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F]
+variable {F₁ : Type*} [NormedAddCommGroup F₁] [NormedSpace ℂ F₁]
+variable {G : Type*} [NormedAddCommGroup G] [NormedSpace ℝ G]
+variable {G₁ : Type*} [NormedAddCommGroup G₁] [NormedSpace ℂ G₁]
+
+
+def Harmonic (f : ℂ → F) : Prop :=
+  (ContDiff ℝ 2 f) ∧ (∀ z, Δ f z = 0)
+
+def HarmonicAt (f : ℂ → F) (x : ℂ) : Prop :=
+  (ContDiffAt ℝ 2 f x) ∧ (Δ f =ᶠ[nhds x] 0)
+
+def HarmonicOn (f : ℂ → F) (s : Set ℂ) : Prop :=
+  (ContDiffOn ℝ 2 f s) ∧ (∀ z ∈ s, Δ f z = 0)
+
+
+theorem HarmonicAt_iff
+  {f : ℂ → F}
+  {x : ℂ} :
+  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 (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₂
+    let s := s₁ ∩ s₂
+    use s
+    constructor
+    · exact IsOpen.inter h₁s₁ h₂s₂
+    · constructor
+      · exact Set.mem_inter h₂s₁ h₃s₂
+      · constructor
+        · exact h₃s₁.mono Set.inter_subset_left
+        · intro z hz
+          exact h₂t₂ (h₁s₂ hz.2)
+  · intro hyp
+    obtain ⟨s, h₁s, h₂s, h₁f, h₂f⟩ := hyp
+    constructor
+    · apply h₁f.contDiffAt
+      apply (IsOpen.mem_nhds_iff h₁s).2 h₂s
+    · apply Filter.eventuallyEq_iff_exists_mem.2
+      use s
+      constructor
+      · apply (IsOpen.mem_nhds_iff h₁s).2 h₂s
+      · exact h₂f
+
+theorem HarmonicAt_isOpen
+  (f : ℂ → F) :
+  IsOpen { x : ℂ | HarmonicAt f x } := by
+
+  rw [← subset_interior_iff_isOpen]
+  intro x hx
+  simp at hx
+  obtain ⟨s, h₁s, h₂s, h₃s⟩ := HarmonicAt_iff.1 hx
+  use s
+  constructor
+  · simp
+    constructor
+    · exact h₁s
+    · intro x hx
+      simp
+      rw [HarmonicAt_iff]
+      use s
+  · exact h₂s
+
+theorem HarmonicAt_eventuallyEq {f₁ f₂ : ℂ → F} {x : ℂ} (h : f₁ =ᶠ[nhds x] f₂) : HarmonicAt f₁ x ↔ HarmonicAt f₂ x := by
+  constructor
+  · intro h₁
+    constructor
+    · exact ContDiffAt.congr_of_eventuallyEq h₁.1 (Filter.EventuallyEq.symm h)
+    · exact Filter.EventuallyEq.trans (laplace_eventuallyEq' (Filter.EventuallyEq.symm h)) h₁.2
+  · intro h₁
+    constructor
+    · exact ContDiffAt.congr_of_eventuallyEq h₁.1 h
+    · exact Filter.EventuallyEq.trans (laplace_eventuallyEq' h) h₁.2
+
+
+theorem HarmonicOn_of_locally_HarmonicOn {f : ℂ → F} {s : Set ℂ} (h : ∀ x ∈ s, ∃ (u : Set ℂ), IsOpen u ∧ x ∈ u ∧ HarmonicOn f (s ∩ u)) :
+  HarmonicOn f s := by
+  constructor
+  · apply contDiffOn_of_locally_contDiffOn
+    intro x xHyp
+    obtain ⟨u, uHyp⟩ := h x xHyp
+    use u
+    exact ⟨ uHyp.1, ⟨uHyp.2.1, uHyp.2.2.1⟩⟩
+  · intro x xHyp
+    obtain ⟨u, uHyp⟩ := h x xHyp
+    exact (uHyp.2.2.2) x ⟨xHyp, uHyp.2.1⟩
+
+
+theorem HarmonicOn_congr {f₁ f₂ : ℂ → F} {s : Set ℂ} (hs : IsOpen s) (hf₁₂ : ∀ x ∈ s, f₁ x = f₂ x) :
+  HarmonicOn f₁ s ↔ HarmonicOn f₂ s := by
+  constructor
+  · intro h₁
+    constructor
+    · apply ContDiffOn.congr h₁.1
+      intro x hx
+      rw [eq_comm]
+      exact hf₁₂ x hx
+    · intro z hz
+      have : f₁ =ᶠ[nhds z] f₂ := by
+        unfold Filter.EventuallyEq
+        unfold Filter.Eventually
+        simp
+        refine mem_nhds_iff.mpr ?_
+        use s
+        constructor
+        · exact hf₁₂
+        · constructor
+          · exact hs
+          · exact hz
+      rw [← laplace_eventuallyEq this]
+      exact h₁.2 z hz
+  · intro h₁
+    constructor
+    · apply ContDiffOn.congr h₁.1
+      intro x hx
+      exact hf₁₂ x hx
+    · intro z hz
+      have : f₁ =ᶠ[nhds z] f₂ := by
+        unfold Filter.EventuallyEq
+        unfold Filter.Eventually
+        simp
+        refine mem_nhds_iff.mpr ?_
+        use s
+        constructor
+        · exact hf₁₂
+        · constructor
+          · exact hs
+          · exact hz
+      rw [laplace_eventuallyEq this]
+      exact h₁.2 z hz
+
+
+theorem harmonic_add_harmonic_is_harmonic {f₁ f₂ : ℂ → F} (h₁ : Harmonic f₁) (h₂ : Harmonic f₂) :
+  Harmonic (f₁ + f₂) := by
+  constructor
+  · exact ContDiff.add h₁.1 h₂.1
+  · rw [laplace_add h₁.1 h₂.1]
+    simp
+    intro z
+    rw [h₁.2 z, h₂.2 z]
+    simp
+
+
+theorem harmonicOn_add_harmonicOn_is_harmonicOn {f₁ f₂ : ℂ → F} {s : Set ℂ} (hs : IsOpen s) (h₁ : HarmonicOn f₁ s) (h₂ : HarmonicOn f₂ s) :
+  HarmonicOn (f₁ + f₂) s := by
+  constructor
+  · exact ContDiffOn.add h₁.1 h₂.1
+  · intro z hz
+    rw [laplace_add_ContDiffOn hs h₁.1 h₂.1 z hz]
+    rw [h₁.2 z hz, h₂.2 z hz]
+    simp
+
+
+theorem harmonicAt_add_harmonicAt_is_harmonicAt
+  {f₁ f₂ : ℂ → F}
+  {x : ℂ}
+  (h₁ : HarmonicAt f₁ x)
+  (h₂ : HarmonicAt f₂ x) :
+  HarmonicAt (f₁ + f₂) x := by
+  constructor
+  · exact ContDiffAt.add h₁.1 h₂.1
+  · apply Filter.EventuallyEq.trans (laplace_add_ContDiffAt' h₁.1 h₂.1)
+    apply Filter.EventuallyEq.trans (Filter.EventuallyEq.add h₁.2 h₂.2)
+    simp
+    rfl
+
+
+theorem harmonic_smul_const_is_harmonic {f : ℂ → F} {c : ℝ} (h : Harmonic f) :
+  Harmonic (c • f) := by
+  constructor
+  · exact ContDiff.const_smul c h.1
+  · rw [laplace_smul]
+    dsimp
+    intro z
+    rw [h.2 z]
+    simp
+
+
+theorem harmonicAt_smul_const_is_harmonicAt
+  {f : ℂ → F}
+  {x : ℂ}
+  {c : ℝ}
+  (h : HarmonicAt f x) :
+  HarmonicAt (c • f) x := by
+  constructor
+  · exact ContDiffAt.const_smul c h.1
+  · rw [laplace_smul]
+    have A := Filter.EventuallyEq.const_smul h.2 c
+    simp at A
+    assumption
+
+
+theorem harmonic_iff_smul_const_is_harmonic {f : ℂ → F} {c : ℝ} (hc : c ≠ 0) :
+  Harmonic f ↔ Harmonic (c • f) := by
+  constructor
+  · exact harmonic_smul_const_is_harmonic
+  · nth_rewrite 2 [((eq_inv_smul_iff₀ hc).mpr rfl : f = c⁻¹ • c • f)]
+    exact fun a => harmonic_smul_const_is_harmonic a
+
+
+theorem harmonicAt_iff_smul_const_is_harmonicAt
+  {f : ℂ → F}
+  {x : ℂ}
+  {c : ℝ}
+  (hc : c ≠ 0) :
+  HarmonicAt f x ↔ HarmonicAt (c • f) x := by
+  constructor
+  · exact harmonicAt_smul_const_is_harmonicAt
+  · nth_rewrite 2 [((eq_inv_smul_iff₀ hc).mpr rfl : f = c⁻¹ • c • f)]
+    exact fun a => harmonicAt_smul_const_is_harmonicAt a
+
+
+theorem harmonic_comp_CLM_is_harmonic {f : ℂ → F₁} {l : F₁ →L[ℝ] G} (h : Harmonic f) :
+  Harmonic (l ∘ f) := by
+
+  constructor
+  · -- Continuous differentiability
+    apply ContDiff.comp
+    exact ContinuousLinearMap.contDiff l
+    exact h.1
+  · rw [laplace_compCLM]
+    simp
+    intro z
+    rw [h.2 z]
+    simp
+    exact ContDiff.restrict_scalars ℝ h.1
+
+
+theorem harmonicOn_comp_CLM_is_harmonicOn {f : ℂ → F₁} {s : Set ℂ} {l : F₁ →L[ℝ] G} (hs : IsOpen s) (h : HarmonicOn f s) :
+  HarmonicOn (l ∘ f) s := by
+
+  constructor
+  · -- Continuous differentiability
+    apply ContDiffOn.continuousLinearMap_comp
+    exact h.1
+  · -- Vanishing of Laplace
+    intro z zHyp
+    rw [laplace_compCLMAt]
+    simp
+    rw [h.2 z]
+    simp
+    assumption
+    apply ContDiffOn.contDiffAt h.1
+    exact IsOpen.mem_nhds hs zHyp
+
+
+theorem harmonicAt_comp_CLM_is_harmonicAt
+  {f : ℂ → F₁}
+  {z : ℂ}
+  {l : F₁ →L[ℝ] G}
+  (h : HarmonicAt f z) :
+  HarmonicAt (l ∘ f) z := by
+
+  constructor
+  · -- ContDiffAt ℝ 2 (⇑l ∘ f) z
+    apply ContDiffAt.continuousLinearMap_comp
+    exact h.1
+  · -- Δ (⇑l ∘ f) =ᶠ[nhds z] 0
+    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
+    apply Filter.eventuallyEq_iff_exists_mem.2
+    use s ∩ u
+    constructor
+    · apply IsOpen.mem_nhds
+      exact IsOpen.inter h₂s h₂u
+      constructor
+      · exact h₃s
+      · exact h₃u
+    · intro x xHyp
+      rw [laplace_compCLMAt]
+      simp
+      rw [h₂t]
+      simp
+      exact h₁u xHyp.2
+      apply (h₂r.mono h₁s).contDiffAt (IsOpen.mem_nhds h₂s xHyp.1)
+
+
+theorem harmonic_iff_comp_CLE_is_harmonic {f : ℂ → F₁} {l : F₁ ≃L[ℝ] G₁} :
+  Harmonic f ↔ Harmonic (l ∘ f) := by
+
+  constructor
+  · have : l ∘ f = (l : F₁ →L[ℝ] G₁) ∘ f := by rfl
+    rw [this]
+    exact harmonic_comp_CLM_is_harmonic
+  · have : f = (l.symm : G₁ →L[ℝ] F₁) ∘ l ∘ f := by
+      funext z
+      unfold Function.comp
+      simp
+    nth_rewrite 2 [this]
+    exact harmonic_comp_CLM_is_harmonic
+
+
+theorem harmonicAt_iff_comp_CLE_is_harmonicAt
+  {f : ℂ → F₁}
+  {z : ℂ}
+  {l : F₁ ≃L[ℝ] G₁} :
+  HarmonicAt f z ↔ HarmonicAt (l ∘ f) z := by
+
+  constructor
+  · have : l ∘ f = (l : F₁ →L[ℝ] G₁) ∘ f := by rfl
+    rw [this]
+    exact harmonicAt_comp_CLM_is_harmonicAt
+  · have : f = (l.symm : G₁ →L[ℝ] F₁) ∘ l ∘ f := by
+      funext z
+      unfold Function.comp
+      simp
+    nth_rewrite 2 [this]
+    exact harmonicAt_comp_CLM_is_harmonicAt
+
+
+theorem harmonicOn_iff_comp_CLE_is_harmonicOn {f : ℂ → F₁} {s : Set ℂ} {l : F₁ ≃L[ℝ] G₁} (hs : IsOpen s) :
+  HarmonicOn f s ↔ HarmonicOn (l ∘ f) s := by
+
+  constructor
+  · have : l ∘ f = (l : F₁ →L[ℝ] G₁) ∘ f := by rfl
+    rw [this]
+    exact harmonicOn_comp_CLM_is_harmonicOn hs
+  · have : f = (l.symm : G₁ →L[ℝ] F₁) ∘ l ∘ f := by
+      funext z
+      unfold Function.comp
+      simp
+    nth_rewrite 2 [this]
+    exact harmonicOn_comp_CLM_is_harmonicOn hs

Nevanlinna/harmonicAt_examples.lean

@@ -0,0 +1,211 @@
+import Mathlib.Analysis.SpecialFunctions.Complex.LogDeriv
+import Nevanlinna.harmonicAt
+import Nevanlinna.holomorphicAt
+
+variable {F : Type*} [NormedAddCommGroup F] [NormedSpace ℂ F] [CompleteSpace F]
+
+
+theorem holomorphicAt_is_harmonicAt
+  {f : ℂ → F}
+  {z : ℂ}
+  (hf : HolomorphicAt f z) :
+  HarmonicAt f z := by
+
+  let t := {x | HolomorphicAt f x}
+  have ht : IsOpen t := HolomorphicAt_isOpen f
+  have hz : z ∈ t := by exact hf
+
+  constructor
+  · -- ContDiffAt ℝ 2 f z
+    exact hf.contDiffAt
+
+  · -- Δ f =ᶠ[nhds z] 0
+    apply Filter.eventuallyEq_iff_exists_mem.2
+    use t
+    constructor
+    · exact IsOpen.mem_nhds ht hz
+    · intro w hw
+      unfold Complex.laplace
+      simp
+      rw [partialDeriv_eventuallyEq ℝ hw.CauchyRiemannAt Complex.I]
+      rw [partialDeriv_smul'₂]
+      simp
+
+      rw [partialDeriv_commAt hw.contDiffAt Complex.I 1]
+      rw [partialDeriv_eventuallyEq ℝ hw.CauchyRiemannAt 1]
+      rw [partialDeriv_smul'₂]
+      simp
+
+      rw [← smul_assoc]
+      simp
+
+
+theorem re_of_holomorphicAt_is_harmonicAr
+  {f : ℂ → ℂ}
+  {z : ℂ}
+  (h : HolomorphicAt f z) :
+  HarmonicAt (Complex.reCLM ∘ f) z := by
+  apply harmonicAt_comp_CLM_is_harmonicAt
+  exact holomorphicAt_is_harmonicAt h
+
+
+theorem im_of_holomorphicAt_is_harmonicAt
+  {f : ℂ → ℂ}
+  {z : ℂ}
+  (h : HolomorphicAt f z) :
+  HarmonicAt (Complex.imCLM ∘ f) z := by
+  apply harmonicAt_comp_CLM_is_harmonicAt
+  exact holomorphicAt_is_harmonicAt h
+
+
+theorem antiholomorphicAt_is_harmonicAt
+  {f : ℂ → ℂ}
+  {z : ℂ}
+  (h : HolomorphicAt f z) :
+  HarmonicAt (Complex.conjCLE ∘ f) z := by
+  apply harmonicAt_iff_comp_CLE_is_harmonicAt.1
+  exact holomorphicAt_is_harmonicAt h
+
+
+theorem log_normSq_of_holomorphicAt_is_harmonicAt
+  {f : ℂ → ℂ}
+  {z : ℂ}
+  (h₁f : HolomorphicAt f z)
+  (h₂f : f z ≠ 0) :
+  HarmonicAt (Real.log ∘ Complex.normSq ∘ f) z := by
+
+  -- For later use
+  have slitPlaneLemma {z : ℂ} (hz : z ≠ 0) : z ∈ Complex.slitPlane ∨ -z ∈ Complex.slitPlane := by
+    rw [Complex.mem_slitPlane_iff, Complex.mem_slitPlane_iff]
+    simp at hz
+    rw [Complex.ext_iff] at hz
+    push_neg at hz
+    simp at hz
+    simp
+    by_contra contra
+    push_neg at contra
+    exact hz (le_antisymm contra.1.1 contra.2.1) contra.1.2
+
+  -- First prove the theorem for functions with image in the slitPlane
+  have lem₁ : ∀ g : ℂ → ℂ, (HolomorphicAt g z) → (g z ≠ 0) → (g z ∈ Complex.slitPlane) → HarmonicAt (Real.log ∘ Complex.normSq ∘ g) z := by
+    intro g h₁g h₂g h₃g
+
+    -- Rewrite the log |g|² as Complex.log (g * gc)
+    suffices hyp : HarmonicAt (Complex.log ∘ ((Complex.conjCLE ∘ g) * g)) z from by
+      have : Real.log ∘ Complex.normSq ∘ g = Complex.reCLM ∘ Complex.ofRealCLM ∘ Real.log ∘ Complex.normSq ∘ g := by
+        funext x
+        simp
+      rw [this]
+
+      have : Complex.ofRealCLM ∘ Real.log ∘ Complex.normSq ∘ g = Complex.log ∘ ((Complex.conjCLE ∘ g) * g) := by
+        funext x
+        simp
+        rw [Complex.ofReal_log]
+        rw [Complex.normSq_eq_conj_mul_self]
+        exact Complex.normSq_nonneg (g x)
+      rw [← this] at hyp
+      apply harmonicAt_comp_CLM_is_harmonicAt hyp
+
+    -- Locally around z, rewrite Complex.log (g * gc) as Complex.log g + Complex.log.gc
+    -- This uses the assumption that g z is in Complex.slitPlane
+    have : (Complex.log ∘ (Complex.conjCLE ∘ g * g)) =ᶠ[nhds z] (Complex.log ∘ Complex.conjCLE ∘ g + Complex.log ∘ g) := by
+      apply Filter.eventuallyEq_iff_exists_mem.2
+      use g⁻¹' (Complex.slitPlane ∩ {0}ᶜ)
+      constructor
+      · apply ContinuousAt.preimage_mem_nhds
+        · exact h₁g.differentiableAt.continuousAt
+        · apply IsOpen.mem_nhds
+          apply IsOpen.inter Complex.isOpen_slitPlane isOpen_ne
+          constructor
+          · exact h₃g
+          · exact h₂g
+      · intro x hx
+        simp
+        rw [Complex.log_mul_eq_add_log_iff _ hx.2]
+        rw [Complex.arg_conj]
+        simp [Complex.slitPlane_arg_ne_pi hx.1]
+        constructor
+        · exact Real.pi_pos
+        · exact Real.pi_nonneg
+        simp
+        apply hx.2
+
+    -- Locally around z, rewrite Complex.log (g * gc) as Complex.log g + Complex.log.gc
+    -- This uses the assumption that g z is in Complex.slitPlane
+    have : (Complex.log ∘ (Complex.conjCLE ∘ g * g)) =ᶠ[nhds z] (Complex.conjCLE ∘ Complex.log ∘ g + Complex.log ∘ g) := by
+      apply Filter.eventuallyEq_iff_exists_mem.2
+      use g⁻¹' (Complex.slitPlane ∩ {0}ᶜ)
+      constructor
+      · apply ContinuousAt.preimage_mem_nhds
+        · exact h₁g.differentiableAt.continuousAt
+        · apply IsOpen.mem_nhds
+          apply IsOpen.inter Complex.isOpen_slitPlane isOpen_ne
+          constructor
+          · exact h₃g
+          · exact h₂g
+      · intro x hx
+        simp
+        rw [← Complex.log_conj]
+        rw [Complex.log_mul_eq_add_log_iff _ hx.2]
+        rw [Complex.arg_conj]
+        simp [Complex.slitPlane_arg_ne_pi hx.1]
+        constructor
+        · exact Real.pi_pos
+        · exact Real.pi_nonneg
+        simp
+        apply hx.2
+        apply Complex.slitPlane_arg_ne_pi hx.1
+
+    rw [HarmonicAt_eventuallyEq this]
+    apply harmonicAt_add_harmonicAt_is_harmonicAt
+    · rw [← harmonicAt_iff_comp_CLE_is_harmonicAt]
+      apply holomorphicAt_is_harmonicAt
+      apply HolomorphicAt_comp
+      use Complex.slitPlane
+      constructor
+      · apply IsOpen.mem_nhds
+        exact Complex.isOpen_slitPlane
+        assumption
+      · exact fun z a => Complex.differentiableAt_log a
+      exact h₁g
+    · apply holomorphicAt_is_harmonicAt
+      apply HolomorphicAt_comp
+      use Complex.slitPlane
+      constructor
+      · apply IsOpen.mem_nhds
+        exact Complex.isOpen_slitPlane
+        assumption
+      · exact fun z a => Complex.differentiableAt_log a
+      exact h₁g
+
+  by_cases h₃f : f z ∈ Complex.slitPlane
+  · exact lem₁ f h₁f h₂f h₃f
+  · have : Complex.normSq ∘ f = Complex.normSq ∘ (-f) := by funext; simp
+    rw [this]
+    apply lem₁ (-f)
+    · exact HolomorphicAt_neg h₁f
+    · simpa
+    · exact (slitPlaneLemma h₂f).resolve_left h₃f
+
+
+theorem logabs_of_holomorphicAt_is_harmonic
+  {f : ℂ → ℂ}
+  {z : ℂ}
+  (h₁f : HolomorphicAt f z)
+  (h₂f : f z ≠ 0) :
+  HarmonicAt (fun w ↦ Real.log ‖f w‖) z := by
+
+  -- Suffices: Harmonic (2⁻¹ • Real.log ∘ ⇑Complex.normSq ∘ f)
+  have : (fun z ↦ Real.log ‖f z‖) = (2 : ℝ)⁻¹ • (Real.log ∘ Complex.normSq ∘ f) := by
+    funext z
+    simp
+    unfold Complex.abs
+    simp
+    rw [Real.log_sqrt]
+    rw [div_eq_inv_mul (Real.log (Complex.normSq (f z))) 2]
+    exact Complex.normSq_nonneg (f z)
+  rw [this]
+
+  -- Suffices: Harmonic (Real.log ∘ ⇑Complex.normSq ∘ f)
+  apply (harmonicAt_iff_smul_const_is_harmonicAt (inv_ne_zero two_ne_zero)).1
+  exact log_normSq_of_holomorphicAt_is_harmonicAt h₁f h₂f

Nevanlinna/harmonicAt_meanValue.lean

@@ -0,0 +1,131 @@
+import Mathlib.Analysis.NormedSpace.Pointwise
+import Mathlib.Topology.MetricSpace.Thickening
+import Mathlib.Analysis.Complex.CauchyIntegral
+import Nevanlinna.holomorphic_examples
+
+theorem harmonic_meanValue
+  {f : ℂ → ℝ}
+  {z : ℂ}
+  (ρ R : ℝ)
+  (hR : 0 < R)
+  (hρ : R < ρ)
+  (hf : ∀ x ∈ Metric.ball z ρ , HarmonicAt f x) :
+  (∫ (x : ℝ) in (0)..2 * Real.pi, f (circleMap z R x)) = 2 * Real.pi * f z
+  := by
+
+  obtain ⟨F, h₁F, h₂F⟩ := harmonic_is_realOfHolomorphic (gt_trans hρ hR) hf
+
+  have hrρ : Metric.ball z R ⊆ Metric.ball z ρ := by
+    intro x hx
+    exact gt_trans hρ hx
+
+  have reg₀F : DifferentiableOn ℂ F (Metric.ball z ρ) := by
+    intro x hx
+    apply DifferentiableAt.differentiableWithinAt
+    apply HolomorphicAt.differentiableAt (h₁F x _)
+    exact hx
+
+  have reg₁F : DifferentiableOn ℂ F (Metric.ball z R) := by
+    intro x hx
+    apply DifferentiableAt.differentiableWithinAt
+    apply HolomorphicAt.differentiableAt (h₁F x _)
+    exact hrρ hx
+
+  have : (∮ (x : ℂ) in C(z, R), (x - z)⁻¹ • F x) = (2 * ↑Real.pi * Complex.I) • F z := by
+    let s : Set ℂ := ∅
+    let hs : s.Countable := Set.countable_empty
+    let _ : ℂ := 0
+    have hw : (z : ℂ) ∈ Metric.ball z R := Metric.mem_ball_self hR
+    have hc : ContinuousOn F (Metric.closedBall z R) := by
+      apply reg₀F.continuousOn.mono
+      intro x hx
+      simp at hx
+      simp
+      linarith
+    have hd : ∀ x ∈ Metric.ball z R \ s, DifferentiableAt ℂ F x := by
+      intro x hx
+      let A := reg₁F x hx.1
+      apply A.differentiableAt
+      apply (IsOpen.mem_nhds_iff ?hs).mpr
+      exact hx.1
+      exact Metric.isOpen_ball
+    let CIF := Complex.circleIntegral_sub_inv_smul_of_differentiable_on_off_countable hs hw hc hd
+    simp at CIF
+    assumption
+
+  unfold circleIntegral at this
+  simp_rw [deriv_circleMap] at this
+
+  have t₁ {θ : ℝ} : (circleMap 0 R θ * Complex.I) • (circleMap 0 R θ)⁻¹ • F (circleMap z R θ) = Complex.I • F (circleMap z R θ) := by
+    rw [← smul_assoc]
+    congr 1
+    simp
+    nth_rw 1 [mul_comm]
+    rw [← mul_assoc]
+    simp
+    apply inv_mul_cancel₀
+    apply circleMap_ne_center
+    exact Ne.symm (ne_of_lt hR)
+  have t'₁  {θ : ℝ} : circleMap 0 R θ = circleMap z R θ - z := by
+    exact Eq.symm (circleMap_sub_center z R θ)
+  simp_rw [← t'₁, t₁] at this
+  simp at this
+
+  have t₂ : Complex.reCLM (-Complex.I * (Complex.I * ∫ (x : ℝ) in (0)..2 * Real.pi, F (circleMap z R x))) = Complex.reCLM (-Complex.I * (2 * ↑Real.pi * Complex.I * F z)) := by
+    rw [this]
+  simp at t₂
+  have xx {x : ℝ} : (F (circleMap z R x)).re = f (circleMap z R x) := by
+    rw [← h₂F]
+    simp
+    simp
+    rw [Complex.dist_eq]
+    rw [circleMap_sub_center]
+    simp
+    rwa [abs_of_nonneg (le_of_lt hR)]
+  have x₁ {z : ℂ} : z.re = Complex.reCLM z := by rfl
+  rw [x₁] at t₂
+  rw [← ContinuousLinearMap.intervalIntegral_comp_comm] at t₂
+  simp at t₂
+  simp_rw [xx] at t₂
+  have x₁ {z : ℂ} : z.re = Complex.reCLM z := by rfl
+  rw [x₁] at t₂
+  have : Complex.reCLM (F z) = f z := by
+    apply h₂F
+    simp
+    exact gt_trans hρ hR
+  rw [this] at t₂
+  exact t₂
+
+  -- IntervalIntegrable (fun x => F (circleMap 0 1 x)) MeasureTheory.volume 0 (2 * Real.pi)
+  apply ContinuousOn.intervalIntegrable
+  apply ContinuousOn.comp reg₀F.continuousOn _
+  intro θ _
+  simp
+  rw [Complex.dist_eq, circleMap_sub_center]
+  simp
+  rwa [abs_of_nonneg (le_of_lt hR)]
+  apply Continuous.continuousOn
+  exact continuous_circleMap z R
+
+/- Probably not optimal yet. We want a statements that requires harmonicity in
+the interior and continuity on the closed ball.
+-/
+
+
+theorem harmonic_meanValue₁
+  {f : ℂ → ℝ}
+  {z : ℂ}
+  (R : ℝ)
+  (hR : 0 < R)
+  (hf : ∀ x ∈ Metric.closedBall z R , HarmonicAt f x) :
+  (∫ (x : ℝ) in (0)..2 * Real.pi, f (circleMap z R x)) = 2 * Real.pi * f z := by
+
+  obtain ⟨e, h₁e, h₂e⟩ := IsCompact.exists_thickening_subset_open (isCompact_closedBall z R) (HarmonicAt_isOpen f) hf
+  rw [thickening_closedBall] at h₂e
+  apply harmonic_meanValue (e + R) R
+  assumption
+  norm_num
+  assumption
+  exact fun x a => h₂e a
+  assumption
+  linarith

Nevanlinna/holomorphicAt.lean

@@ -0,0 +1,194 @@
+import Mathlib.Analysis.Complex.CauchyIntegral
+import Nevanlinna.cauchyRiemann
+
+variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
+variable {F : Type*} [NormedAddCommGroup F] [NormedSpace ℂ F]
+variable {G : Type*} [NormedAddCommGroup G] [NormedSpace ℂ G]
+
+def HolomorphicAt (f : E → F) (x : E) : Prop :=
+  ∃ s ∈ nhds x, ∀ z ∈ s, DifferentiableAt ℂ f z
+
+
+theorem HolomorphicAt_iff
+  {f : E → F}
+  {x : E} :
+  HolomorphicAt f x ↔ ∃ s :
+  Set E, IsOpen s ∧ x ∈ s ∧ (∀ z ∈ s, DifferentiableAt ℂ f z) := by
+  constructor
+  · intro hf
+    obtain ⟨t, h₁t, h₂t⟩ := hf
+    obtain ⟨s, h₁s, h₂s, h₃s⟩ := mem_nhds_iff.1 h₁t
+    use s
+    constructor
+    · assumption
+    · constructor
+      · assumption
+      · intro z hz
+        exact h₂t z (h₁s hz)
+  · intro hyp
+    obtain ⟨s, h₁s, h₂s, hf⟩ := hyp
+    use s
+    constructor
+    · apply (IsOpen.mem_nhds_iff h₁s).2 h₂s
+    · assumption
+
+
+theorem Differentiable.holomorphicAt
+  {f : E → F}
+  (hf : Differentiable ℂ f)
+  {x : E} :
+  HolomorphicAt f x := by
+  apply HolomorphicAt_iff.2
+  use Set.univ
+  constructor
+  · exact isOpen_univ
+  · constructor
+    · exact trivial
+    · intro z _
+      exact hf z
+
+
+theorem HolomorphicAt_isOpen
+  (f : E → F) :
+  IsOpen { x : E | HolomorphicAt f x } := by
+
+  rw [← subset_interior_iff_isOpen]
+  intro x hx
+  simp at hx
+  obtain ⟨s, h₁s, h₂s, h₃s⟩ := HolomorphicAt_iff.1 hx
+  use s
+  constructor
+  · simp
+    constructor
+    · exact h₁s
+    · intro x hx
+      simp
+      use s
+      constructor
+      · exact IsOpen.mem_nhds h₁s hx
+      · exact h₃s
+  · exact h₂s
+
+
+theorem HolomorphicAt_comp
+  {g : E → F}
+  {f : F → G}
+  {z : E}
+  (hf : HolomorphicAt f (g z))
+  (hg : HolomorphicAt g z) :
+  HolomorphicAt (f ∘ g) z := by
+  obtain ⟨UE, h₁UE, h₂UE⟩ := hg
+  obtain ⟨UF, h₁UF, h₂UF⟩ := hf
+  use UE ∩ g⁻¹' UF
+  constructor
+  · simp
+    constructor
+    · assumption
+    · apply ContinuousAt.preimage_mem_nhds
+      apply (h₂UE z (mem_of_mem_nhds h₁UE)).continuousAt
+      assumption
+  · intro x hx
+    apply DifferentiableAt.comp
+    apply h₂UF
+    exact hx.2
+    apply h₂UE
+    exact hx.1
+
+
+theorem HolomorphicAt_neg
+  {f : E → F}
+  {z : E}
+  (hf : HolomorphicAt f z) :
+  HolomorphicAt (-f) z := by
+  obtain ⟨UF, h₁UF, h₂UF⟩ := hf
+  use UF
+  constructor
+  · assumption
+  · intro z hz
+    apply differentiableAt_neg_iff.mp
+    simp
+    exact h₂UF z hz
+
+
+theorem HolomorphicAt.analyticAt
+  [CompleteSpace F]
+  {f : ℂ → F}
+  {x : ℂ} :
+  HolomorphicAt f x → AnalyticAt ℂ f x := by
+  intro hf
+  obtain ⟨s, h₁s, h₂s, h₃s⟩ := HolomorphicAt_iff.1 hf
+  apply DifferentiableOn.analyticAt (s := s)
+  intro z hz
+  apply DifferentiableAt.differentiableWithinAt
+  apply h₃s
+  exact hz
+  exact IsOpen.mem_nhds h₁s h₂s
+
+
+theorem AnalyticAt.holomorphicAt
+  [CompleteSpace F]
+  {f : ℂ → F}
+  {x : ℂ} :
+  AnalyticAt ℂ f x → HolomorphicAt f x := by
+  intro hf
+  rw [HolomorphicAt_iff]
+  use {x : ℂ | AnalyticAt ℂ f x}
+  constructor
+  · exact isOpen_analyticAt ℂ f
+  · constructor
+    · simpa
+    · intro z hz
+      simp at hz
+      exact differentiableAt hz
+
+
+theorem HolomorphicAt.contDiffAt
+  [CompleteSpace F]
+  {f : ℂ → F}
+  {z : ℂ}
+  {n : ℕ}
+  (hf : HolomorphicAt f z) :
+  ContDiffAt ℝ n f z := by
+
+  let t := {x | HolomorphicAt f x}
+  have ht : IsOpen t := HolomorphicAt_isOpen f
+  have hz : z ∈ t := by exact hf
+
+  -- ContDiffAt ℝ _ f z
+  apply ContDiffOn.contDiffAt _ ((IsOpen.mem_nhds_iff ht).2 hz)
+  suffices h : ContDiffOn ℂ n f t from by
+    apply ContDiffOn.restrict_scalars ℝ h
+  apply DifferentiableOn.contDiffOn _ ht
+  intro w hw
+  apply DifferentiableAt.differentiableWithinAt
+  -- DifferentiableAt ℂ f w
+  let hfw : HolomorphicAt f w := hw
+  obtain ⟨s, _, h₂s, h₃s⟩ := HolomorphicAt_iff.1 hfw
+  exact h₃s w h₂s
+
+
+theorem HolomorphicAt.differentiableAt
+  {f : ℂ → F}
+  {z : ℂ}
+  (hf : HolomorphicAt f z) :
+  DifferentiableAt ℂ f z := by
+  obtain ⟨s, _, h₂s, h₃s⟩ := HolomorphicAt_iff.1 hf
+  exact h₃s z h₂s
+
+
+theorem HolomorphicAt.CauchyRiemannAt
+  {f : ℂ → F}
+  {z : ℂ}
+  (h : HolomorphicAt f z) :
+  partialDeriv ℝ Complex.I f =ᶠ[nhds z] Complex.I • partialDeriv ℝ 1 f := by
+
+  obtain ⟨s, h₁s, hz, h₂f⟩ := HolomorphicAt_iff.1 h
+
+  apply Filter.eventuallyEq_iff_exists_mem.2
+  use s
+  constructor
+  · exact IsOpen.mem_nhds h₁s hz
+  · intro w hw
+    let h := h₂f w hw
+    unfold partialDeriv
+    apply CauchyRiemann₅ h

Nevanlinna/holomorphic_examples.lean

@@ -0,0 +1,314 @@
+import Nevanlinna.harmonicAt
+import Nevanlinna.holomorphicAt
+import Nevanlinna.holomorphic_primitive
+import Nevanlinna.mathlibAddOn
+
+
+theorem CauchyRiemann₆
+  {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
+  {F : Type*} [NormedAddCommGroup F] [NormedSpace ℂ F]
+  {f : E → F}
+  {z : E} :
+  (DifferentiableAt ℂ f z) ↔ (DifferentiableAt ℝ f z) ∧ ∀ e, partialDeriv ℝ (Complex.I • e) f z = Complex.I • partialDeriv ℝ e f z := by
+  constructor
+
+  · -- Direction "→"
+    intro h
+    constructor
+    · exact DifferentiableAt.restrictScalars ℝ h
+    · unfold partialDeriv
+      conv =>
+        intro e
+        left
+        rw [DifferentiableAt.fderiv_restrictScalars ℝ h]
+        simp
+        rw [← mul_one Complex.I]
+        rw [← smul_eq_mul]
+      conv =>
+        intro e
+        right
+        right
+        rw [DifferentiableAt.fderiv_restrictScalars ℝ h]
+      simp
+
+  · -- Direction "←"
+    intro ⟨h₁, h₂⟩
+    apply (differentiableAt_iff_restrictScalars ℝ h₁).2
+
+    use {
+      toFun := fderiv ℝ f z
+      map_add' := fun x y => ContinuousLinearMap.map_add (fderiv ℝ f z) x y
+      map_smul' := by
+        simp
+        intro m x
+        have : m = m.re + m.im • Complex.I := by simp
+        rw [this, add_smul, add_smul, ContinuousLinearMap.map_add]
+        congr
+        simp
+        rw [smul_assoc, smul_assoc, ContinuousLinearMap.map_smul (fderiv ℝ f z) m.2]
+        congr
+        exact h₂ x
+    }
+    rfl
+
+
+theorem CauchyRiemann₇
+  {F : Type*} [NormedAddCommGroup F] [NormedSpace ℂ F]
+  {f : ℂ → F}
+  {z : ℂ} :
+  (DifferentiableAt ℂ f z) ↔ (DifferentiableAt ℝ f z) ∧ partialDeriv ℝ Complex.I f z = Complex.I • partialDeriv ℝ 1 f z := by
+  constructor
+  · intro hf
+    constructor
+    · exact (CauchyRiemann₆.1 hf).1
+    · let A := (CauchyRiemann₆.1 hf).2 1
+      simp at A
+      exact A
+  · intro ⟨h₁, h₂⟩
+    apply CauchyRiemann₆.2
+    constructor
+    · exact h₁
+    · intro e
+      have : Complex.I • e = e • Complex.I := by
+        rw [smul_eq_mul, smul_eq_mul]
+        exact CommMonoid.mul_comm Complex.I e
+      rw [this]
+      have : e = e.re + e.im • Complex.I := by simp
+      rw [this, add_smul, partialDeriv_add₁, partialDeriv_add₁]
+      simp
+      rw [← smul_eq_mul]
+      have : partialDeriv ℝ ((e.re : ℝ) • Complex.I) f = partialDeriv ℝ ((e.re : ℂ) • Complex.I) f := by rfl
+      rw [← this, partialDeriv_smul₁ ℝ]
+      have : (e.re : ℂ) = (e.re : ℝ) • (1 : ℂ) := by simp
+      rw [this, partialDeriv_smul₁ ℝ]
+      have : partialDeriv ℝ ((e.im : ℂ) * Complex.I) f = partialDeriv ℝ ((e.im : ℝ) • Complex.I) f := by rfl
+      rw [this, partialDeriv_smul₁ ℝ]
+      simp
+      rw [h₂]
+      rw [smul_comm]
+      congr
+      rw [mul_assoc]
+      simp
+      nth_rw 2 [smul_comm]
+      rw [← smul_assoc]
+      simp
+      have : - (e.im : ℂ) = (-e.im : ℝ) • (1 : ℂ) := by simp
+      rw [this, partialDeriv_smul₁ ℝ]
+      simp
+
+
+
+
+/-
+
+A harmonic, real-valued function on ℂ is the real part of a suitable holomorphic
+function.
+
+-/
+
+theorem harmonic_is_realOfHolomorphic
+  {f : ℂ → ℝ}
+  {z : ℂ}
+  {R : ℝ}
+  (hR : 0 < R)
+  (hf : ∀ x ∈ Metric.ball z R, HarmonicAt f x) :
+  ∃ F : ℂ → ℂ, (∀ x ∈ Metric.ball z R, HolomorphicAt F x) ∧ (Set.EqOn (Complex.reCLM ∘ F) f (Metric.ball z R)) := by
+
+  let f_1 : ℂ → ℂ := Complex.ofRealCLM ∘ (partialDeriv ℝ 1 f)
+  let f_I : ℂ → ℂ := Complex.ofRealCLM ∘ (partialDeriv ℝ Complex.I f)
+
+  let g : ℂ → ℂ := f_1 - Complex.I • f_I
+
+  have contDiffOn_if_contDiffAt
+    {f' : ℂ → ℝ}
+    {z' : ℂ}
+    {R' : ℝ}
+    {n' : ℕ}
+    (hf' : ∀ x ∈ Metric.ball z' R', ContDiffAt ℝ n' f' x) :
+    ContDiffOn ℝ n' f' (Metric.ball z' R') := by
+    intro z hz
+    apply ContDiffAt.contDiffWithinAt
+    exact hf' z hz
+
+  have reg₂f : ContDiffOn ℝ 2 f (Metric.ball z R) := by
+    apply contDiffOn_if_contDiffAt
+    intro x hx
+    exact (hf x hx).1
+
+  have contDiffOn_if_contDiffAt'
+    {f' : ℂ → ℂ}
+    {z' : ℂ}
+    {R' : ℝ}
+    {n' : ℕ}
+    (hf' : ∀ x ∈ Metric.ball z' R', ContDiffAt ℝ n' f' x) :
+    ContDiffOn ℝ n' f' (Metric.ball z' R') := by
+    intro z hz
+    apply ContDiffAt.contDiffWithinAt
+    exact hf' z hz
+
+  have reg₁f_1 : ContDiffOn ℝ 1 f_1 (Metric.ball z R) := by
+    apply contDiffOn_if_contDiffAt'
+    intro z hz
+    dsimp [f_1]
+    apply ContDiffAt.continuousLinearMap_comp
+    exact partialDeriv_contDiffAt ℝ (hf z hz).1 1
+
+  have reg₁f_I : ContDiffOn ℝ 1 f_I (Metric.ball z R) := by
+    apply contDiffOn_if_contDiffAt'
+    intro z hz
+    dsimp [f_I]
+    apply ContDiffAt.continuousLinearMap_comp
+    exact partialDeriv_contDiffAt ℝ (hf z hz).1 Complex.I
+
+  have reg₁g : ContDiffOn ℝ 1 g (Metric.ball z R) := by
+    dsimp [g]
+    apply ContDiffOn.sub
+    exact reg₁f_1
+    have : Complex.I • f_I = fun x ↦ Complex.I • f_I x := by rfl
+    rw [this]
+    apply ContDiffOn.const_smul
+    exact reg₁f_I
+
+  have reg₁ : DifferentiableOn ℂ g (Metric.ball z R) := by
+    intro x hx
+    apply DifferentiableAt.differentiableWithinAt
+    apply CauchyRiemann₇.2
+    constructor
+    · apply DifferentiableWithinAt.differentiableAt (reg₁g.differentiableOn le_rfl x hx)
+      apply IsOpen.mem_nhds Metric.isOpen_ball hx
+    · dsimp [g]
+      rw [partialDeriv_sub₂_differentiableAt, partialDeriv_sub₂_differentiableAt]
+      dsimp [f_1, f_I]
+      rw [partialDeriv_smul'₂, partialDeriv_smul'₂]
+      rw [partialDeriv_compContLinAt, partialDeriv_compContLinAt]
+      simp
+      rw [partialDeriv_compContLinAt, partialDeriv_compContLinAt]
+      rw [mul_sub]
+      simp
+      rw [← mul_assoc]
+      simp
+      rw [add_comm, sub_eq_add_neg]
+      congr 1
+      · rw [partialDeriv_commOn _ reg₂f Complex.I 1]
+        exact hx
+        exact Metric.isOpen_ball
+      · let A := Filter.EventuallyEq.eq_of_nhds (hf x hx).2
+        simp at A
+        unfold Complex.laplace at A
+        conv =>
+          right
+          right
+          rw [← sub_zero (partialDeriv ℝ 1 (partialDeriv ℝ 1 f) x)]
+          rw [← A]
+        simp
+
+      --DifferentiableAt ℝ (partialDeriv ℝ _ f)
+      repeat
+        apply ContDiffAt.differentiableAt (n := 1)
+        apply partialDeriv_contDiffAt ℝ (hf x hx).1
+        apply le_rfl
+
+      -- DifferentiableAt ℝ f_1 x
+      apply (reg₁f_1.differentiableOn le_rfl).differentiableAt
+      apply IsOpen.mem_nhds Metric.isOpen_ball hx
+
+      -- DifferentiableAt ℝ (Complex.I • f_I)
+      have : Complex.I • f_I = fun x ↦ Complex.I • f_I x := by rfl
+      rw [this]
+      apply DifferentiableAt.const_smul
+      apply (reg₁f_I.differentiableOn le_rfl).differentiableAt
+      apply IsOpen.mem_nhds Metric.isOpen_ball hx
+
+      -- Differentiable ℝ f_1
+      apply (reg₁f_1.differentiableOn le_rfl).differentiableAt
+      apply IsOpen.mem_nhds Metric.isOpen_ball hx
+
+      -- Differentiable ℝ (Complex.I • f_I)
+      have : Complex.I • f_I = fun x ↦ Complex.I • f_I x := by rfl
+      rw [this]
+      apply DifferentiableAt.const_smul
+      apply (reg₁f_I.differentiableOn le_rfl).differentiableAt
+      apply IsOpen.mem_nhds Metric.isOpen_ball hx
+
+  let F := fun z' ↦ (primitive z g) z' + f z
+
+  have regF : DifferentiableOn ℂ F (Metric.ball z R) := by
+    apply DifferentiableOn.add
+    apply primitive_differentiableOn reg₁
+    simp
+
+  have pF'' : ∀ x ∈ Metric.ball z R, (fderiv ℝ F x) = ContinuousLinearMap.lsmul ℝ ℂ (g x) := by
+    intro x hx
+    have : DifferentiableAt ℂ F x := by
+      apply (regF x hx).differentiableAt
+      apply IsOpen.mem_nhds Metric.isOpen_ball hx
+    rw [DifferentiableAt.fderiv_restrictScalars ℝ this]
+    dsimp [F]
+    rw [fderiv_add_const]
+    rw [primitive_fderiv' reg₁ x hx]
+    exact rfl
+
+  use F
+
+  constructor
+  · -- ∀ x ∈ Metric.ball z R, HolomorphicAt F x
+    intro x hx
+    apply HolomorphicAt_iff.2
+    use Metric.ball z R
+    constructor
+    · exact Metric.isOpen_ball
+    · constructor
+      · assumption
+      · intro w hw
+        apply (regF w hw).differentiableAt
+        apply IsOpen.mem_nhds Metric.isOpen_ball hw
+  · -- Set.EqOn (⇑Complex.reCLM ∘ F) f (Metric.ball z R)
+    have : DifferentiableOn ℝ (Complex.reCLM ∘ F) (Metric.ball z R) := by
+      apply DifferentiableOn.comp
+      apply Differentiable.differentiableOn
+      apply ContinuousLinearMap.differentiable Complex.reCLM
+      apply regF.restrictScalars ℝ
+      exact Set.mapsTo'.mpr fun ⦃a⦄ _ => hR
+    have hz : z ∈ Metric.ball z R := by exact Metric.mem_ball_self hR
+    apply Convex.eqOn_of_fderivWithin_eq _ this _ _ _ hz _
+    exact convex_ball z R
+    apply reg₂f.differentiableOn one_le_two
+    apply IsOpen.uniqueDiffOn Metric.isOpen_ball
+
+    intro x hx
+    rw [fderivWithin_eq_fderiv, fderivWithin_eq_fderiv]
+    rw [fderiv_comp]
+    simp
+    apply ContinuousLinearMap.ext
+    intro w
+    simp
+    rw [pF'']
+    dsimp [g, f_1, f_I, partialDeriv]
+    simp
+    have : w = w.re • 1 + w.im • Complex.I := by simp
+    nth_rw 3 [this]
+    rw [(fderiv ℝ f x).map_add]
+    rw [(fderiv ℝ f x).map_smul, (fderiv ℝ f x).map_smul]
+    rw [smul_eq_mul, smul_eq_mul]
+    ring
+
+    assumption
+    exact ContinuousLinearMap.differentiableAt Complex.reCLM
+    apply (regF.restrictScalars ℝ  x hx).differentiableAt
+    apply IsOpen.mem_nhds Metric.isOpen_ball hx
+    apply IsOpen.uniqueDiffOn Metric.isOpen_ball
+    assumption
+    apply (reg₂f.differentiableOn one_le_two).differentiableAt
+    apply IsOpen.mem_nhds Metric.isOpen_ball hx
+    apply IsOpen.uniqueDiffOn Metric.isOpen_ball
+    assumption
+    -- DifferentiableAt ℝ (⇑Complex.reCLM ∘ F) x
+    apply DifferentiableAt.comp
+    apply Differentiable.differentiableAt
+    exact ContinuousLinearMap.differentiable Complex.reCLM
+    apply (regF.restrictScalars ℝ  x hx).differentiableAt
+    apply IsOpen.mem_nhds Metric.isOpen_ball hx
+    --
+    dsimp [F]
+    rw [primitive_zeroAtBasepoint]
+    simp

Nevanlinna/holomorphic_primitive.lean

@@ -0,0 +1,846 @@
+import Mathlib.Analysis.Complex.TaylorSeries
+import Mathlib.Data.ENNReal.Basic
+
+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}
+  {R : ℝ}
+  (hR : 0 < R)
+  (hf : ContinuousOn f (Metric.ball 0 R)) :
+  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]
+
+  obtain ⟨s, h₁s, h₂s⟩ : ∃ s ⊆ f⁻¹' Metric.ball (f 0) (c / (4 : ℝ)), IsOpen s ∧ 0 ∈ s := by
+    apply eventually_nhds_iff.mp
+    apply continuousAt_def.1
+    apply Continuous.continuousAt
+    fun_prop
+
+    apply continuousAt_def.1
+    apply hf.continuousAt
+    exact Metric.ball_mem_nhds 0 hR
+    apply Metric.ball_mem_nhds (f 0)
+    simpa
+
+  obtain ⟨ε, h₁ε, h₂ε⟩ : ∃ ε > 0, (Metric.ball 0 ε) ×ℂ (Metric.ball 0 ε) ⊆ s ∧ (Metric.ball 0 ε) ×ℂ (Metric.ball 0 ε) ⊆ Metric.ball 0 R := by
+    obtain ⟨ε', h₁ε', h₂ε'⟩ : ∃ ε' > 0, Metric.ball 0 ε' ⊆ s ∩ Metric.ball 0 R := by
+      apply Metric.mem_nhds_iff.mp
+      apply IsOpen.mem_nhds
+      apply IsOpen.inter
+      exact h₂s.1
+      exact Metric.isOpen_ball
+      constructor
+      · exact h₂s.2
+      · simpa
+
+    use (2 : ℝ)⁻¹ * ε'
+
+    constructor
+    · simpa
+    · constructor
+      · intro x hx
+        apply (h₂ε' _).1
+        simp
+        calc Complex.abs x
+        _ ≤ |x.re| + |x.im| := Complex.abs_le_abs_re_add_abs_im x
+        _ < (2 : ℝ)⁻¹ * ε' + |x.im| := by
+          apply (add_lt_add_iff_right |x.im|).mpr
+          have : x.re ∈ Metric.ball 0 (2⁻¹ * ε') := (Complex.mem_reProdIm.1 hx).1
+          simp at this
+          exact this
+        _ < (2 : ℝ)⁻¹ * ε' + (2 : ℝ)⁻¹ * ε' := by
+          apply (add_lt_add_iff_left ((2 : ℝ)⁻¹ * ε')).mpr
+          have : x.im ∈ Metric.ball 0 (2⁻¹ * ε') := (Complex.mem_reProdIm.1 hx).2
+          simp at this
+          exact this
+        _ = ε' := by
+          rw [← add_mul]
+          abel_nf
+          simp
+      · intro x hx
+        apply (h₂ε' _).2
+        simp
+        calc Complex.abs x
+        _ ≤ |x.re| + |x.im| := Complex.abs_le_abs_re_add_abs_im x
+        _ < (2 : ℝ)⁻¹ * ε' + |x.im| := by
+          apply (add_lt_add_iff_right |x.im|).mpr
+          have : x.re ∈ Metric.ball 0 (2⁻¹ * ε') := (Complex.mem_reProdIm.1 hx).1
+          simp at this
+          exact this
+        _ < (2 : ℝ)⁻¹ * ε' + (2 : ℝ)⁻¹ * ε' := by
+          apply (add_lt_add_iff_left ((2 : ℝ)⁻¹ * ε')).mpr
+          have : x.im ∈ Metric.ball 0 (2⁻¹ * ε') := (Complex.mem_reProdIm.1 hx).2
+          simp at this
+          exact this
+        _ = ε' := by
+          rw [← add_mul]
+          abel_nf
+          simp
+
+  have h₃ε : ∀ y ∈ (Metric.ball 0 ε) ×ℂ (Metric.ball 0 ε), ‖(f y) - (f 0)‖ < (c / (4 : ℝ)) := by
+    intro y hy
+    apply mem_ball_iff_norm.mp
+    apply h₁s
+    exact h₂ε.1 hy
+
+
+  have intervalComputation_uIcc {x' y' : ℝ} (h : x' ∈ Set.uIcc 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
+      rwa [abs_of_nonneg A, abs_of_nonneg hy]
+    · simp [hy] at A
+      simp [hy] at B
+      rw [abs_of_nonpos hy]
+      rw [abs_of_nonpos]
+      linarith [h.1]
+      exact B
+
+
+  rw [Filter.eventually_iff_exists_mem]
+  use Metric.ball 0 (ε / (4 : ℝ))
+
+  constructor
+  · apply Metric.ball_mem_nhds 0
+    linarith
+  · intro y hy
+
+    have {A B C D :E} : (A + B) - (C + D) = (A - C) + (B - D) := by
+      abel
+    rw [this]
+    rw [← smul_sub]
+
+
+    have t₀ : IntervalIntegrable (fun x => f { re := x, im := 0 }) MeasureTheory.volume 0 y.re := by
+      apply ContinuousOn.intervalIntegrable
+      apply ContinuousOn.comp
+      exact hf
+      have : (fun x => ({ re := x, im := 0 } : ℂ)) = Complex.ofRealLI := by rfl
+      rw [this]
+      apply Continuous.continuousOn
+      continuity
+      intro x hx
+      apply h₂ε.2
+      simp
+      constructor
+      · simp
+        calc |x|
+        _ ≤ |y.re| := by apply intervalComputation_uIcc hx
+        _ ≤ Complex.abs y := by exact Complex.abs_re_le_abs y
+        _ < ε / 4 := by simp at hy; assumption
+        _ < ε := by linarith
+      · simpa
+    have t₁ : IntervalIntegrable (fun _ => f 0) MeasureTheory.volume 0 y.re := by
+      apply ContinuousOn.intervalIntegrable
+      apply ContinuousOn.comp
+      apply hf
+      fun_prop
+      intro x _
+      simpa
+    rw [← intervalIntegral.integral_sub t₀ t₁]
+
+    have t₂ : IntervalIntegrable (fun x_1 => f { re := y.re, im := x_1 }) MeasureTheory.volume 0 y.im := by
+      apply ContinuousOn.intervalIntegrable
+      apply ContinuousOn.comp
+      exact hf
+      have : (Complex.mk y.re) = (fun x => Complex.I • Complex.ofRealCLM x + { re := y.re, im := 0 }) := by
+        funext x
+        apply Complex.ext
+        rw [Complex.add_re]
+        simp
+        simp
+      rw [this]
+      apply ContinuousOn.add
+      apply Continuous.continuousOn
+      continuity
+      fun_prop
+      intro x hx
+      apply h₂ε.2
+      constructor
+      · simp
+        calc |y.re|
+        _ ≤ Complex.abs y := by exact Complex.abs_re_le_abs y
+        _ < ε / 4 := by simp at hy; assumption
+        _ < ε := by linarith
+      · simp
+        calc |x|
+        _ ≤ |y.im| := by apply intervalComputation_uIcc hx
+        _ ≤ Complex.abs y := by exact Complex.abs_im_le_abs y
+        _ < ε / 4 := by simp at hy; assumption
+        _ < ε := by linarith
+    have t₃ : IntervalIntegrable (fun _ => f 0) MeasureTheory.volume 0 y.im := by
+      apply ContinuousOn.intervalIntegrable
+      apply ContinuousOn.comp
+      exact hf
+      fun_prop
+      intro x _
+      apply h₂ε.2
+      simp
+      constructor
+      · simpa
+      · simpa
+    rw [← intervalIntegral.integral_sub t₂ t₃]
+
+    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 }
+      constructor
+      · simp
+        linarith
+      · simp
+        exact h₁ε
+
+    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 }
+      constructor
+      · simp
+        linarith
+      · simp
+        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}
+  {R : ℝ}
+  (z₀ : ℂ)
+  (hR : 0 < R)
+  (hf : ContinuousOn f (Metric.ball z₀ R)) :
+  HasDerivAt (primitive z₀ f) (f z₀) z₀ := by
+
+  let g := f ∘ fun z ↦ z + z₀
+  have hg : ContinuousOn g (Metric.ball 0 R) := by
+    apply ContinuousOn.comp
+    fun_prop
+    fun_prop
+    intro x hx
+    simp
+    simp at hx
+    assumption
+
+  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₀) := (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 primitive_fderivAtBasepointZero hR hg
+  apply HasDerivAt.sub_const
+  have : (fun (x : ℂ) ↦ x) = id := by
+    funext x
+    simp
+  rw [this]
+  exact hasDerivAt_id z₀
+
+
+theorem primitive_additivity
+  {E : Type u} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
+  {f : ℂ  → E}
+  {z₀ : ℂ}
+  {rx ry : ℝ}
+  (hf : DifferentiableOn ℂ f (Metric.ball z₀.re rx ×ℂ Metric.ball z₀.im ry))
+  (hry : 0 < ry)
+  {z₁ : ℂ}
+  (hz₁ : z₁ ∈ (Metric.ball z₀.re rx ×ℂ Metric.ball z₀.im ry))
+  :
+  ∃ εx > 0, ∃ εy > 0, ∀ z ∈ (Metric.ball z₁.re εx ×ℂ Metric.ball z₁.im εy), (primitive z₀ f z) - (primitive z₁ f z) - (primitive z₀ f z₁) = 0 := by
+
+  let εx := rx - dist z₀.re z₁.re
+  have hεx : εx > 0 := by
+    let A := hz₁.1
+    simp at A
+    dsimp [εx]
+    rw [dist_comm]
+    simpa
+  let εy := ry - dist z₀.im z₁.im
+  have hεy : εy > 0 := by
+    let A := hz₁.2
+    simp at A
+    dsimp [εy]
+    rw [dist_comm]
+    simpa
+
+  use εx
+  use hεx
+  use εy
+  use hεy
+
+  intro z hz
+
+  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]
+
+    -- IntervalIntegrable (fun x => f { re := x, im := z₀.im }) MeasureTheory.volume z₀.re z₁.re
+    apply ContinuousOn.intervalIntegrable
+    apply ContinuousOn.comp
+    exact hf.continuousOn
+    have {b : ℝ} : ((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
+    apply Continuous.continuousOn
+    rw [this]
+    continuity
+    -- Remains: Set.MapsTo (fun x => { re := x, im := z₀.im }) (Set.uIcc z₀.re z₁.re) (Metric.ball z₀.re rx ×ℂ Metric.ball z₀.im ry)
+    intro w hw
+    simp
+    apply Complex.mem_reProdIm.mpr
+    constructor
+    · simp
+      calc dist w z₀.re
+      _ ≤ dist z₁.re z₀.re := by apply Real.dist_right_le_of_mem_uIcc; rwa [Set.uIcc_comm] at hw
+      _ < rx := by apply Metric.mem_ball.mp (Complex.mem_reProdIm.1 hz₁).1
+    · simpa
+
+    -- IntervalIntegrable (fun x => f { re := x, im := z₀.im }) MeasureTheory.volume z₁.re z.re
+    apply ContinuousOn.intervalIntegrable
+    apply ContinuousOn.comp
+    exact hf.continuousOn
+    have {b : ℝ} : ((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
+    apply Continuous.continuousOn
+    rw [this]
+    continuity
+    -- Remains: Set.MapsTo (fun x => { re := x, im := z₀.im }) (Set.uIcc z₁.re z.re) (Metric.ball z₀.re rx ×ℂ Metric.ball z₀.im ry)
+    intro w hw
+    simp
+    constructor
+    · simp
+      calc dist w z₀.re
+      _ ≤ dist w z₁.re + dist z₁.re z₀.re := by exact dist_triangle w z₁.re z₀.re
+      _ ≤ dist z.re z₁.re + dist z₁.re z₀.re := by
+        apply (add_le_add_iff_right (dist z₁.re z₀.re)).mpr
+        rw [Set.uIcc_comm] at hw
+        exact Real.dist_right_le_of_mem_uIcc hw
+      _ < (rx - dist z₀.re z₁.re) + dist z₁.re z₀.re := by
+        apply (add_lt_add_iff_right (dist z₁.re z₀.re)).mpr
+        apply Metric.mem_ball.1 (Complex.mem_reProdIm.1 hz).1
+      _ = rx := by
+        rw [dist_comm]
+        simp
+    · simpa
+  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]
+
+    -- IntervalIntegrable (fun x => f { re := z.re, im := x }) MeasureTheory.volume z₀.im z₁.im
+    apply ContinuousOn.intervalIntegrable
+    apply ContinuousOn.comp
+    exact hf.continuousOn
+    apply Continuous.continuousOn
+    have {b : ℝ}:  (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
+    fun_prop
+    fun_prop
+    -- Set.MapsTo (Complex.mk z.re) (Set.uIcc z₀.im z₁.im) (Metric.ball z₀.re rx ×ℂ Metric.ball z₀.im ry)
+    intro w hw
+    constructor
+    · simp
+      calc dist z.re z₀.re
+      _ ≤ dist z.re z₁.re + dist z₁.re z₀.re := by exact dist_triangle z.re z₁.re z₀.re
+      _ < (rx - dist z₀.re z₁.re) + dist z₁.re z₀.re := by
+        apply (add_lt_add_iff_right (dist z₁.re z₀.re)).mpr
+        apply Metric.mem_ball.1 (Complex.mem_reProdIm.1 hz).1
+      _ = rx := by
+        rw [dist_comm]
+        simp
+    · simp
+      calc dist w z₀.im
+      _ ≤ dist z₁.im z₀.im := by rw [Set.uIcc_comm] at hw; exact Real.dist_right_le_of_mem_uIcc hw
+      _ < ry := by
+        rw [← Metric.mem_ball]
+        exact hz₁.2
+
+    -- IntervalIntegrable (fun x => f { re := z.re, im := x }) MeasureTheory.volume z₁.im z.im
+    apply ContinuousOn.intervalIntegrable
+    apply ContinuousOn.comp
+    exact hf.continuousOn
+    apply Continuous.continuousOn
+    have {b : ℝ}:  (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
+    fun_prop
+    fun_prop
+    -- Set.MapsTo (Complex.mk z.re) (Set.uIcc z₁.im z.im) (Metric.ball z₀.re rx ×ℂ Metric.ball z₀.im ry)
+    intro w hw
+    constructor
+    · simp
+      calc dist z.re z₀.re
+      _ ≤ dist z.re z₁.re + dist z₁.re z₀.re := by exact dist_triangle z.re z₁.re z₀.re
+      _ < (rx - dist z₀.re z₁.re) + dist z₁.re z₀.re := by
+        apply (add_lt_add_iff_right (dist z₁.re z₀.re)).mpr
+        apply Metric.mem_ball.1 (Complex.mem_reProdIm.1 hz).1
+      _ = rx := by
+        rw [dist_comm]
+        simp
+    · simp
+      calc dist w z₀.im
+      _ ≤ dist w z₁.im + dist z₁.im z₀.im := by exact dist_triangle w z₁.im z₀.im
+      _ ≤ dist z.im z₁.im + dist z₁.im z₀.im := by
+        apply (add_le_add_iff_right (dist z₁.im z₀.im)).mpr
+        rw [Set.uIcc_comm] at hw
+        exact Real.dist_right_le_of_mem_uIcc hw
+      _ < (ry - dist z₀.im z₁.im) + dist z₁.im z₀.im := by
+        apply (add_lt_add_iff_right (dist z₁.im z₀.im)).mpr
+        apply Metric.mem_ball.1 (Complex.mem_reProdIm.1 hz).2
+      _ = ry := by
+        rw [dist_comm]
+        simp
+  rw [this]
+
+  simp
+
+  have {a b c d e f g h : E} : (a + b) + (c + d) - (e + f) - (g + h) = b + (a - g) - e - f + d  - h + (c) := by
+    abel
+  rw [this]
+
+
+  have H' : DifferentiableOn ℂ f (Set.uIcc z₁.re z.re ×ℂ Set.uIcc z₀.im z₁.im) := by
+    apply DifferentiableOn.mono hf
+    intro x hx
+    constructor
+    · simp
+      calc dist x.re z₀.re
+      _ ≤ dist x.re z₁.re + dist z₁.re z₀.re := by exact dist_triangle x.re z₁.re z₀.re
+      _ ≤ dist z.re z₁.re + dist z₁.re z₀.re := by
+        apply (add_le_add_iff_right (dist z₁.re z₀.re)).mpr
+        rw [Set.uIcc_comm] at hx
+        apply Real.dist_right_le_of_mem_uIcc (Complex.mem_reProdIm.1 hx).1
+      _ < (rx - dist z₀.re z₁.re) + dist z₁.re z₀.re := by
+        apply (add_lt_add_iff_right (dist z₁.re z₀.re)).mpr
+        apply Metric.mem_ball.1 (Complex.mem_reProdIm.1 hz).1
+      _ = rx := by
+        rw [dist_comm]
+        simp
+    · simp
+      calc dist x.im z₀.im
+      _ ≤ dist z₀.im z₁.im := by rw [dist_comm]; exact Real.dist_left_le_of_mem_uIcc (Complex.mem_reProdIm.1 hx).2
+      _ < ry := by
+        rw [dist_comm]
+        exact Metric.mem_ball.1 (Complex.mem_reProdIm.1 hz₁).2
+
+  let A := Complex.integral_boundary_rect_eq_zero_of_differentiableOn f ⟨z₁.re, z₀.im⟩ ⟨z.re, z₁.im⟩ H'
+  have {x : ℝ} {w : ℂ} : ↑x + w.im * Complex.I = { re := x, im := w.im } := by
+    apply Complex.ext
+    · simp
+    · simp
+  simp_rw [this] at A
+  have {x : ℝ} {w : ℂ} : w.re + x * Complex.I = { re := w.re, im := x } := by
+    apply Complex.ext
+    · simp
+    · simp
+  simp_rw [this] at A
+  rw [← A]
+  abel
+
+
+theorem primitive_additivity'
+  {E : Type u} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
+  {f : ℂ  → E}
+  {z₀ z₁ : ℂ}
+  {R : ℝ}
+  (hf : DifferentiableOn ℂ f (Metric.ball z₀ R))
+  (hz₁ : z₁ ∈ Metric.ball z₀ R)
+  :
+  primitive z₀ f =ᶠ[nhds z₁] fun z ↦ (primitive z₁ f z) + (primitive z₀ f z₁) := by
+
+  let d := fun ε ↦ √((dist z₁.re z₀.re + ε) ^ 2 + (dist z₁.im z₀.im + ε) ^ 2)
+  have h₀d : Continuous d := by continuity
+  have h₁d : ∀ ε, 0 ≤ d ε := fun ε ↦ Real.sqrt_nonneg ((dist z₁.re z₀.re + ε) ^ 2 + (dist z₁.im z₀.im + ε) ^ 2)
+
+  obtain ⟨ε, h₀ε, h₁ε⟩ : ∃ ε > 0, d ε < R := by
+    let Omega := d⁻¹' Metric.ball 0 R
+
+    have lem₀Ω : IsOpen Omega := IsOpen.preimage h₀d Metric.isOpen_ball
+    have lem₁Ω : 0 ∈ Omega := by
+      dsimp [Omega, d]; simp
+      have : dist z₁.re z₀.re = |z₁.re - z₀.re| := by exact rfl
+      rw [this]
+      have : dist z₁.im z₀.im = |z₁.im - z₀.im| := by exact rfl
+      rw [this]
+      simp
+      rw [← Complex.dist_eq_re_im]; simp
+      exact hz₁
+    obtain ⟨ε, h₁ε, h₂ε⟩ := Metric.isOpen_iff.1 lem₀Ω 0 lem₁Ω
+
+    let ε' := (2 : ℝ)⁻¹ * ε
+
+    have h₀ε' : ε' ∈ Omega := by
+      apply h₂ε
+      dsimp [ε']; simp
+      have : |ε| = ε := by apply abs_of_pos h₁ε
+      rw [this]
+      apply (inv_mul_lt_iff₀ zero_lt_two).mpr
+      linarith
+    have h₁ε' : 0 < ε' := by
+      apply mul_pos _ h₁ε
+      apply inv_pos.mpr
+      exact zero_lt_two
+
+    use ε'
+
+    constructor
+    · exact h₁ε'
+    · dsimp [Omega] at h₀ε'; simp at h₀ε'
+      rwa [abs_of_nonneg (h₁d ε')] at h₀ε'
+
+  let rx := dist z₁.re z₀.re + ε
+  let ry := dist z₁.im z₀.im + ε
+
+  have h'ry : 0 < ry := by
+    dsimp [ry]
+    apply add_pos_of_nonneg_of_pos
+    exact dist_nonneg
+    simpa
+
+  have h'f : DifferentiableOn ℂ f (Metric.ball z₀.re rx ×ℂ Metric.ball z₀.im ry) := by
+    apply hf.mono
+    intro x hx
+    simp
+    rw [Complex.dist_eq_re_im]
+
+    have t₀ : dist x.re z₀.re < rx := Metric.mem_ball.mp hx.1
+    have t₁ : dist x.im z₀.im < ry := Metric.mem_ball.mp hx.2
+    have t₂ : √((x.re - z₀.re) ^ 2 + (x.im - z₀.im) ^ 2) < √( rx ^ 2 + ry ^ 2) := by
+      rw [Real.sqrt_lt_sqrt_iff]
+      apply add_lt_add
+      · rw [sq_lt_sq]
+        dsimp [dist] at t₀
+        nth_rw 2 [abs_of_nonneg]
+        assumption
+        apply add_nonneg dist_nonneg (le_of_lt h₀ε)
+      · rw [sq_lt_sq]
+        dsimp [dist] at t₁
+        nth_rw 2 [abs_of_nonneg]
+        assumption
+        apply add_nonneg dist_nonneg (le_of_lt h₀ε)
+      apply add_nonneg
+      exact sq_nonneg (x.re - z₀.re)
+      exact sq_nonneg (x.im - z₀.im)
+
+    calc √((x.re - z₀.re) ^ 2 + (x.im - z₀.im) ^ 2)
+    _ < √( rx ^ 2 + ry ^ 2) := by
+      exact t₂
+    _ = d ε := by dsimp [d, rx, ry]
+    _ < R := by exact h₁ε
+
+  have h'z₁ : z₁ ∈ (Metric.ball z₀.re rx ×ℂ Metric.ball z₀.im ry) := by
+    dsimp [rx, ry]
+    constructor
+    · simp; exact h₀ε
+    · simp; exact h₀ε
+
+  obtain ⟨εx, hεx, εy, hεy, hε⟩ := primitive_additivity h'f h'ry h'z₁
+
+  apply Filter.eventuallyEq_iff_exists_mem.2
+  use (Metric.ball z₁.re εx ×ℂ Metric.ball z₁.im εy)
+  constructor
+  · apply IsOpen.mem_nhds
+    apply IsOpen.reProdIm
+    exact Metric.isOpen_ball
+    exact Metric.isOpen_ball
+    constructor
+    · simpa
+    · simpa
+  · intro x hx
+    simp
+    rw [← sub_zero (primitive z₀ f x), ← hε x hx]
+    abel
+
+
+theorem primitive_hasDerivAt
+  {E : Type u} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
+  {f : ℂ  → E}
+  {z₀ z : ℂ}
+  {R : ℝ}
+  (hf : DifferentiableOn ℂ f (Metric.ball z₀ R))
+  (hz : z ∈ Metric.ball z₀ R) :
+  HasDerivAt (primitive z₀ f) (f z) z := by
+
+  let A := primitive_additivity' hf hz
+  rw [Filter.EventuallyEq.hasDerivAt_iff A]
+  rw [← add_zero (f z)]
+  apply HasDerivAt.add
+
+  let R' := R - dist z z₀
+  have h₀R' : 0 < R' := by
+    dsimp [R']
+    simp
+    exact hz
+  have h₁R' : Metric.ball z R' ⊆ Metric.ball z₀ R := by
+    intro x hx
+    simp
+    calc dist x z₀
+    _ ≤ dist x z + dist z z₀ := dist_triangle x z z₀
+    _ < R' + dist z z₀ := by
+      refine add_lt_add_right ?bc (dist z z₀)
+      exact hx
+    _ = R := by
+      dsimp [R']
+      simp
+
+  apply primitive_hasDerivAtBasepoint
+  exact h₀R'
+  apply ContinuousOn.mono hf.continuousOn h₁R'
+  apply hasDerivAt_const
+
+
+theorem primitive_differentiableOn
+  {E : Type u} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
+  {f : ℂ  → E}
+  {z₀ : ℂ}
+  {R : ℝ}
+  (hf : DifferentiableOn ℂ f (Metric.ball z₀ R))
+  :
+  DifferentiableOn ℂ (primitive z₀ f) (Metric.ball z₀ R) := by
+  intro z hz
+  apply DifferentiableAt.differentiableWithinAt
+  exact (primitive_hasDerivAt hf hz).differentiableAt
+
+
+theorem primitive_hasFderivAt
+  {E : Type u} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
+  {f : ℂ  → E}
+  (z₀ : ℂ)
+  (R : ℝ)
+  (hf : DifferentiableOn ℂ f (Metric.ball z₀ R))
+  :
+  ∀ z ∈ Metric.ball z₀ R, HasFDerivAt (primitive z₀ f) ((ContinuousLinearMap.lsmul ℂ ℂ).flip (f z)) z := by
+  intro z hz
+  rw [hasFDerivAt_iff_hasDerivAt]
+  simp
+  apply primitive_hasDerivAt hf hz
+
+
+theorem primitive_hasFderivAt'
+  {f : ℂ  → ℂ}
+  {z₀ : ℂ}
+  {R : ℝ}
+  (hf : DifferentiableOn ℂ f (Metric.ball z₀ R))
+  :
+  ∀ z ∈ Metric.ball z₀ R, HasFDerivAt (primitive z₀ f) (ContinuousLinearMap.lsmul ℂ ℂ (f z)) z := by
+  intro z hz
+  rw [hasFDerivAt_iff_hasDerivAt]
+  simp
+  exact primitive_hasDerivAt hf hz
+
+
+theorem primitive_fderiv
+  {E : Type u} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E]
+  {f : ℂ  → E}
+  {z₀ : ℂ}
+  {R : ℝ}
+  (hf : DifferentiableOn ℂ f (Metric.ball z₀ R))
+  :
+  ∀ z ∈ Metric.ball z₀ R, (fderiv ℂ (primitive z₀ f) z) = (ContinuousLinearMap.lsmul ℂ ℂ).flip (f z) := by
+  intro z hz
+  apply HasFDerivAt.fderiv
+  exact primitive_hasFderivAt z₀ R hf z hz
+
+
+theorem primitive_fderiv'
+  {f : ℂ  → ℂ}
+  {z₀ : ℂ}
+  {R : ℝ}
+  (hf : DifferentiableOn ℂ f (Metric.ball z₀ R))
+  :
+  ∀ z ∈ Metric.ball z₀ R, (fderiv ℂ (primitive z₀ f) z) = ContinuousLinearMap.lsmul ℂ ℂ (f z) := by
+  intro z hz
+  apply HasFDerivAt.fderiv
+  exact primitive_hasFderivAt' hf z hz

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/laplace.lean

@@ -1,30 +1,36 @@
-import Mathlib.Data.Fin.Tuple.Basic
 import Mathlib.Analysis.Complex.Basic
-import Mathlib.Analysis.Complex.TaylorSeries
-import Mathlib.Analysis.Calculus.LineDeriv.Basic
-import Mathlib.Analysis.Calculus.ContDiff.Defs
-import Mathlib.Analysis.Calculus.FDeriv.Basic
-import Mathlib.Analysis.Calculus.FDeriv.Symmetric
-import Mathlib.Data.Complex.Module
-import Mathlib.Data.Complex.Order
-import Mathlib.Data.Complex.Exponential
-import Mathlib.Analysis.RCLike.Basic
-import Mathlib.Order.Filter.Basic
-import Mathlib.Topology.Algebra.InfiniteSum.Module
-import Mathlib.Topology.Basic
-import Mathlib.Topology.Instances.RealVectorSpace
-import Nevanlinna.cauchyRiemann
 import Nevanlinna.partialDeriv
 
 variable {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F]
 variable {G : Type*} [NormedAddCommGroup G] [NormedSpace ℝ G]
 
 
-noncomputable def Complex.laplace : (ℂ → F) → (ℂ → F) :=
-  fun f ↦ partialDeriv ℝ 1 (partialDeriv ℝ 1 f) + partialDeriv ℝ Complex.I (partialDeriv ℝ Complex.I f)
+noncomputable def Complex.laplace (f : ℂ → F) : ℂ → F :=
+  partialDeriv ℝ 1 (partialDeriv ℝ 1 f) + partialDeriv ℝ Complex.I (partialDeriv ℝ Complex.I f)
+
+notation "Δ" => Complex.laplace
 
 
-theorem laplace_add {f₁ f₂ : ℂ → F} (h₁ : ContDiff ℝ 2 f₁)  (h₂ : ContDiff ℝ 2 f₂): Complex.laplace (f₁ + f₂) = (Complex.laplace f₁) + (Complex.laplace f₂) := by
+theorem laplace_eventuallyEq {f₁ f₂ : ℂ → F} {x : ℂ} (h : f₁ =ᶠ[nhds x] f₂) : Δ f₁ x = Δ f₂ x := by
+  unfold Complex.laplace
+  simp
+  rw [partialDeriv_eventuallyEq ℝ (partialDeriv_eventuallyEq' ℝ h 1) 1]
+  rw [partialDeriv_eventuallyEq ℝ (partialDeriv_eventuallyEq' ℝ h Complex.I) Complex.I]
+
+
+theorem laplace_eventuallyEq' {f₁ f₂ : ℂ → F} {x : ℂ} (h : f₁ =ᶠ[nhds x] f₂) : Δ f₁ =ᶠ[nhds x] Δ f₂ := by
+  unfold Complex.laplace
+  apply Filter.EventuallyEq.add
+  exact partialDeriv_eventuallyEq' ℝ (partialDeriv_eventuallyEq' ℝ h 1) 1
+  exact partialDeriv_eventuallyEq' ℝ (partialDeriv_eventuallyEq' ℝ h Complex.I) Complex.I
+
+
+theorem laplace_add
+  {f₁ f₂ : ℂ → F}
+  (h₁ : ContDiff ℝ 2 f₁)
+  (h₂ : ContDiff ℝ 2 f₂) :
+  Δ (f₁ + f₂) = (Δ f₁) + (Δ f₂) := by
+
   unfold Complex.laplace
   rw [partialDeriv_add₂]
   rw [partialDeriv_add₂]
@@ -46,44 +52,174 @@ theorem laplace_add {f₁ f₂ : ℂ → F} (h₁ : ContDiff ℝ 2 f₁)  (h₂
   exact h₂.differentiable one_le_two
 
 
-theorem laplace_smul {f : ℂ → F} (h : ContDiff ℝ 2 f) : ∀ v : ℝ, Complex.laplace (v • f) = v • (Complex.laplace f) := by
+theorem laplace_add_ContDiffOn
+  {f₁ f₂ : ℂ → F}
+  {s : Set ℂ}
+  (hs : IsOpen s)
+  (h₁ : ContDiffOn ℝ 2 f₁ s)
+  (h₂ : ContDiffOn ℝ 2 f₂ s) :
+  ∀ x ∈ s, Δ (f₁ + f₂) x = (Δ f₁) x + (Δ f₂) x := by
+
+  unfold Complex.laplace
+  simp
+  intro x hx
+
+  have hf₁ : ∀ z ∈ s, DifferentiableAt ℝ f₁ z := by
+    intro z hz
+    convert DifferentiableOn.differentiableAt _ (IsOpen.mem_nhds hs hz)
+    apply ContDiffOn.differentiableOn h₁ one_le_two
+  have hf₂ : ∀ z ∈ s, DifferentiableAt ℝ f₂ z := by
+    intro z hz
+    convert DifferentiableOn.differentiableAt _ (IsOpen.mem_nhds hs hz)
+    apply ContDiffOn.differentiableOn h₂ one_le_two
+  have : partialDeriv ℝ 1 (f₁ + f₂) =ᶠ[nhds x] (partialDeriv ℝ 1 f₁) + (partialDeriv ℝ 1 f₂) := by
+    apply Filter.eventuallyEq_iff_exists_mem.2
+    use s
+    constructor
+    · exact IsOpen.mem_nhds hs hx
+    · intro z hz
+      apply partialDeriv_add₂_differentiableAt
+      exact hf₁ z hz
+      exact hf₂ z hz
+  rw [partialDeriv_eventuallyEq ℝ this]
+  have t₁ : DifferentiableAt ℝ (partialDeriv ℝ 1 f₁) x := by
+    let B₀ := (h₁ x hx).contDiffAt (IsOpen.mem_nhds hs hx)
+    let A₀ := partialDeriv_contDiffAt ℝ B₀ 1
+    apply A₀.differentiableAt (Preorder.le_refl 1)
+  have t₂ : DifferentiableAt ℝ (partialDeriv ℝ 1 f₂) x := by
+    let B₀ := (h₂ x hx).contDiffAt (IsOpen.mem_nhds hs hx)
+    let A₀ := partialDeriv_contDiffAt ℝ B₀ 1
+    exact A₀.differentiableAt (Preorder.le_refl 1)
+  rw [partialDeriv_add₂_differentiableAt ℝ t₁ t₂]
+
+  have : partialDeriv ℝ Complex.I (f₁ + f₂) =ᶠ[nhds x] (partialDeriv ℝ Complex.I f₁) + (partialDeriv ℝ Complex.I f₂) := by
+    apply Filter.eventuallyEq_iff_exists_mem.2
+    use s
+    constructor
+    · exact IsOpen.mem_nhds hs hx
+    · intro z hz
+      apply partialDeriv_add₂_differentiableAt
+      exact hf₁ z hz
+      exact hf₂ z hz
+  rw [partialDeriv_eventuallyEq ℝ this]
+  have t₃ : DifferentiableAt ℝ (partialDeriv ℝ Complex.I f₁) x := by
+    let B₀ := (h₁ x hx).contDiffAt (IsOpen.mem_nhds hs hx)
+    let A₀ := partialDeriv_contDiffAt ℝ B₀ Complex.I
+    exact A₀.differentiableAt (Preorder.le_refl 1)
+  have t₄ : DifferentiableAt ℝ (partialDeriv ℝ Complex.I f₂) x := by
+    let B₀ := (h₂ x hx).contDiffAt (IsOpen.mem_nhds hs hx)
+    let A₀ := partialDeriv_contDiffAt ℝ B₀ Complex.I
+    exact A₀.differentiableAt (Preorder.le_refl 1)
+  rw [partialDeriv_add₂_differentiableAt ℝ t₃ t₄]
+
+  -- I am super confused at this point because the tactic 'ring' does not work.
+  -- I do not understand why. So, I need to do things by hand.
+  rw [add_assoc]
+  rw [add_assoc]
+  rw [add_right_inj (partialDeriv ℝ 1 (partialDeriv ℝ 1 f₁) x)]
+  rw [add_comm]
+  rw [add_assoc]
+  rw [add_right_inj (partialDeriv ℝ Complex.I (partialDeriv ℝ Complex.I f₁) x)]
+  rw [add_comm]
+
+
+theorem laplace_add_ContDiffAt
+  {f₁ f₂ : ℂ → F}
+  {x : ℂ}
+  (h₁ : ContDiffAt ℝ 2 f₁ x)
+  (h₂ : ContDiffAt ℝ 2 f₂ x) :
+  Δ (f₁ + f₂) x = (Δ f₁) x + (Δ f₂) x := by
+
+  unfold Complex.laplace
+  simp
+
+  have h₁₁ : ContDiffAt ℝ 1 f₁ x := h₁.of_le one_le_two
+  have h₂₁ : ContDiffAt ℝ 1 f₂ x := h₂.of_le one_le_two
+  repeat
+    rw [partialDeriv_eventuallyEq ℝ (partialDeriv_add₂_contDiffAt ℝ h₁₁ h₂₁)]
+    rw [partialDeriv_add₂_differentiableAt]
+
+  -- I am super confused at this point because the tactic 'ring' does not work.
+  -- I do not understand why. So, I need to do things by hand.
+  rw [add_assoc]
+  rw [add_assoc]
+  rw [add_right_inj (partialDeriv ℝ 1 (partialDeriv ℝ 1 f₁) x)]
+  rw [add_comm]
+  rw [add_assoc]
+  rw [add_right_inj (partialDeriv ℝ Complex.I (partialDeriv ℝ Complex.I f₁) x)]
+  rw [add_comm]
+
+  repeat
+    apply fun v ↦ (partialDeriv_contDiffAt ℝ h₁ v).differentiableAt le_rfl
+    apply fun v ↦ (partialDeriv_contDiffAt ℝ h₂ v).differentiableAt le_rfl
+
+
+theorem laplace_add_ContDiffAt'
+  {f₁ f₂ : ℂ → F}
+  {x : ℂ}
+  (h₁ : ContDiffAt ℝ 2 f₁ x)
+  (h₂ : ContDiffAt ℝ 2 f₂ x) :
+  Δ (f₁ + f₂) =ᶠ[nhds x] (Δ f₁) + (Δ f₂):= by
+
+  unfold Complex.laplace
+
+  rw [add_assoc]
+  nth_rw  5 [add_comm]
+  rw [add_assoc]
+  rw [← add_assoc]
+
+  have dualPDeriv : ∀ v : ℂ, partialDeriv ℝ v (partialDeriv ℝ v (f₁ + f₂)) =ᶠ[nhds x]
+    partialDeriv ℝ v (partialDeriv ℝ v f₁) + partialDeriv ℝ v (partialDeriv ℝ v f₂) := by
+
+    intro v
+    have h₁₁ : ContDiffAt ℝ 1 f₁ x := h₁.of_le one_le_two
+    have h₂₁ : ContDiffAt ℝ 1 f₂ x := h₂.of_le one_le_two
+
+    have t₁ : partialDeriv ℝ v (partialDeriv ℝ v (f₁ + f₂)) =ᶠ[nhds x] partialDeriv ℝ v (partialDeriv ℝ v f₁ + partialDeriv ℝ v f₂) := by
+      exact partialDeriv_eventuallyEq' ℝ (partialDeriv_add₂_contDiffAt ℝ h₁₁ h₂₁) v
+
+    have t₂ : partialDeriv ℝ v (partialDeriv ℝ v f₁ + partialDeriv ℝ v f₂) =ᶠ[nhds x] (partialDeriv ℝ v (partialDeriv ℝ v f₁)) + (partialDeriv ℝ v (partialDeriv ℝ v f₂)) := by
+      apply partialDeriv_add₂_contDiffAt ℝ
+      apply partialDeriv_contDiffAt
+      exact h₁
+      apply partialDeriv_contDiffAt
+      exact h₂
+
+    apply Filter.EventuallyEq.trans t₁ t₂
+
+  have eventuallyEq_add
+    {a₁ a₂ b₁ b₂ : ℂ → F}
+    (h : a₁ =ᶠ[nhds x] b₁)
+    (h' : a₂ =ᶠ[nhds x] b₂) : (a₁ + a₂) =ᶠ[nhds x] (b₁ + b₂) := by
+    have {c₁ c₂ : ℂ → F} : (fun x => c₁ x + c₂ x) = c₁ + c₂ := by rfl
+    rw [← this, ← this]
+    exact Filter.EventuallyEq.add h h'
+  apply eventuallyEq_add
+  · exact dualPDeriv 1
+  · nth_rw 2 [add_comm]
+    exact dualPDeriv Complex.I
+
+
+theorem laplace_smul {f : ℂ → F} : ∀ v : ℝ, Δ (v • f) = v • (Δ f) := by
   intro v
   unfold Complex.laplace
-  rw [partialDeriv_smul₂]
-  rw [partialDeriv_smul₂]
-  rw [partialDeriv_smul₂]
-  rw [partialDeriv_smul₂]
+  repeat
+    rw [partialDeriv_smul₂]
   simp
 
-  exact (partialDeriv_contDiff ℝ h Complex.I).differentiable le_rfl
-  exact h.differentiable one_le_two
-  exact (partialDeriv_contDiff ℝ h 1).differentiable le_rfl
-  exact h.differentiable one_le_two
 
+theorem laplace_compCLMAt
+  {f : ℂ → F}
+  {l : F →L[ℝ] G}
+  {x : ℂ}
+  (h : ContDiffAt ℝ 2 f x) :
+  Δ (l ∘ f) x = (l ∘ (Δ f)) x := by
 
-theorem laplace_compContLin {f : ℂ → F} {l : F →L[ℝ] G} (h : ContDiff ℝ 2 f) :
-  Complex.laplace (l ∘ f) = l ∘ (Complex.laplace f) := by
-  unfold Complex.laplace
-  rw [partialDeriv_compContLin]
-  rw [partialDeriv_compContLin]
-  rw [partialDeriv_compContLin]
-  rw [partialDeriv_compContLin]
-  simp
-
-  exact (partialDeriv_contDiff ℝ h Complex.I).differentiable le_rfl
-  exact h.differentiable one_le_two
-  exact (partialDeriv_contDiff ℝ h 1).differentiable le_rfl
-  exact h.differentiable one_le_two
-
-
-theorem laplace_compContLinAt {f : ℂ → F} {l : F →L[ℝ] G} {x : ℂ} (h : ContDiffAt ℝ 2 f x) :
-  Complex.laplace (l ∘ f) x = (l ∘ (Complex.laplace f)) x := by
-
-  have A₂ : ∃ v ∈ nhds x, (IsOpen v) ∧ (x ∈ v) ∧ (ContDiffOn ℝ 2 f v) := by
-    have : ∃ u ∈ nhds x, ContDiffOn ℝ 2 f u := by
-      apply ContDiffAt.contDiffOn h 
+  obtain ⟨v, hv₁, hv₂, hv₃, hv₄⟩ : ∃ v ∈ nhds x, (IsOpen v) ∧ (x ∈ v) ∧ (ContDiffOn ℝ 2 f v) := by
+    obtain ⟨u, hu₁, hu₂⟩ : ∃ u ∈ nhds x, ContDiffOn ℝ 2 f u := by
+      apply ContDiffAt.contDiffOn h
       rfl
-    obtain ⟨u, hu₁, hu₂⟩ := this
+      simp
     obtain ⟨v, hv₁, hv₂, hv₃⟩ := mem_nhds_iff.1 hu₁
     use v
     constructor
@@ -92,8 +228,7 @@ theorem laplace_compContLinAt {f : ℂ → F} {l : F →L[ℝ] G} {x : ℂ} (h :
       exact hv₂
       constructor
       · exact hv₃
-      · exact ContDiffOn.congr_mono hu₂ (fun x => congrFun rfl) hv₁    
-  obtain ⟨v, hv₁, hv₂, hv₃, hv₄⟩ := A₂
+      · exact ContDiffOn.congr_mono hu₂ (fun x => congrFun rfl) hv₁
 
   have D : ∀ w : ℂ, partialDeriv ℝ w (l ∘ f) =ᶠ[nhds x] l ∘ partialDeriv ℝ w (f) := by
     intro w
@@ -119,17 +254,24 @@ theorem laplace_compContLinAt {f : ℂ → F} {l : F →L[ℝ] G} {x : ℂ} (h :
   simp
 
   -- DifferentiableAt ℝ (partialDeriv ℝ Complex.I f) x
-  apply ContDiffAt.differentiableAt (partialDeriv_contDiffAt ℝ (ContDiffOn.contDiffAt hv₄ hv₁) Complex.I)
-  rfl
+  apply ContDiffAt.differentiableAt (partialDeriv_contDiffAt ℝ (ContDiffOn.contDiffAt hv₄ hv₁) Complex.I) le_rfl
 
   -- DifferentiableAt ℝ (partialDeriv ℝ 1 f) x
-  apply ContDiffAt.differentiableAt (partialDeriv_contDiffAt ℝ (ContDiffOn.contDiffAt hv₄ hv₁) 1)
-  rfl
+  apply ContDiffAt.differentiableAt (partialDeriv_contDiffAt ℝ (ContDiffOn.contDiffAt hv₄ hv₁) 1) le_rfl
 
 
-theorem laplace_compCLE {f : ℂ → F} {l : F ≃L[ℝ] G} (h : ContDiff ℝ 2 f) :
-  Complex.laplace (l ∘ f) = l ∘ (Complex.laplace f) := by
-  let l' := (l : F →L[ℝ] G)
-  have : Complex.laplace (l' ∘ f) = l' ∘ (Complex.laplace f) := by
-    exact laplace_compContLin h
-  exact this
+theorem laplace_compCLM
+  {f : ℂ → F}
+  {l : F →L[ℝ] G}
+  (h : ContDiff ℝ 2 f) :
+  Δ (l ∘ f) = l ∘ (Δ f) := by
+  funext z
+  exact laplace_compCLMAt h.contDiffAt
+
+
+theorem laplace_compCLE {f : ℂ → F} {l : F ≃L[ℝ] G} :
+  Δ (l ∘ f) = l ∘ (Δ f) := by
+  unfold Complex.laplace
+  repeat
+    rw [partialDeriv_compCLE]
+  simp

Nevanlinna/leftovers/analyticOnNhd_divisor.lean

@@ -0,0 +1,59 @@
+import Nevanlinna.analyticAt
+import Nevanlinna.divisor
+
+open scoped Interval Topology
+open Real Filter MeasureTheory intervalIntegral
+
+
+noncomputable def AnalyticOnNhd.zeroDivisor
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (hf : AnalyticOnNhd ℂ f U) :
+  Divisor U where
+
+  toFun := by
+    intro z
+    if hz : z ∈ U then
+      exact ((hf z hz).order.toNat : ℤ)
+    else
+      exact 0
+
+  supportInU := by
+    intro z hz
+    simp at hz
+    by_contra h₂z
+    simp [h₂z] at hz
+
+  locallyFiniteInU := by
+    intro z hz
+
+    apply eventually_nhdsWithin_iff.2
+    rw [eventually_nhds_iff]
+
+    rcases AnalyticAt.eventually_eq_zero_or_eventually_ne_zero (hf z hz) with h|h
+    · rw [eventually_nhds_iff] at h
+      obtain ⟨N, h₁N, h₂N, h₃N⟩ := h
+      use N
+      constructor
+      · intro y h₁y _
+        by_cases h₃y : y ∈ U
+        · simp [h₃y]
+          right
+          rw [AnalyticAt.order_eq_top_iff (hf y h₃y)]
+          rw [eventually_nhds_iff]
+          use N
+        · simp [h₃y]
+      · tauto
+
+    · rw [eventually_nhdsWithin_iff, eventually_nhds_iff] at h
+      obtain ⟨N, h₁N, h₂N, h₃N⟩ := h
+      use N
+      constructor
+      · intro y h₁y h₂y
+        by_cases h₃y : y ∈ U
+        · simp [h₃y]
+          left
+          rw [AnalyticAt.order_eq_zero_iff (hf y h₃y)]
+          exact h₁N y h₁y h₂y
+        · simp [h₃y]
+      · tauto

Nevanlinna/leftovers/analyticOnNhd_zeroSet.lean

@@ -0,0 +1,461 @@
+import Mathlib.Analysis.Analytic.Constructions
+import Mathlib.Analysis.Analytic.IsolatedZeros
+import Mathlib.Analysis.Complex.Basic
+import Nevanlinna.analyticAt
+
+
+noncomputable def AnalyticOnNhd.order
+  {f : ℂ → ℂ} {U : Set ℂ} (hf : AnalyticOnNhd ℂ f U) : U → ℕ∞ := fun u ↦ (hf u u.2).order
+
+
+theorem AnalyticOnNhd.order_eq_nat_iff
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  {z₀ : U}
+  (hf : AnalyticOnNhd ℂ f U)
+  (n : ℕ) :
+  hf.order z₀ = ↑n ↔ ∃ (g : ℂ → ℂ), AnalyticOnNhd ℂ g U ∧ g z₀ ≠ 0 ∧ ∀ z, f z = (z - z₀) ^ n • g z := by
+
+  constructor
+  -- Direction →
+  intro hn
+  obtain ⟨gloc, h₁gloc, h₂gloc, h₃gloc⟩ := (AnalyticAt.order_eq_nat_iff (hf z₀ z₀.2) n).1 hn
+
+  -- Define a candidate function; this is (f z) / (z - z₀) ^ n with the
+  -- removable singularity removed
+  let g : ℂ → ℂ := fun z ↦ if z = z₀ then gloc z₀ else (f z) / (z - z₀) ^ n
+
+  -- Describe g near z₀
+  have g_near_z₀ : ∀ᶠ (z : ℂ) in nhds z₀, g z = gloc z := by
+    rw [eventually_nhds_iff]
+    obtain ⟨t, h₁t, h₂t, h₃t⟩ := eventually_nhds_iff.1 h₃gloc
+    use t
+    constructor
+    · intro y h₁y
+      by_cases h₂y : y = z₀
+      · dsimp [g]; simp [h₂y]
+      · dsimp [g]; simp [h₂y]
+        rw [div_eq_iff_mul_eq, eq_comm, mul_comm]
+        exact h₁t y h₁y
+        norm_num
+        rw [sub_eq_zero]
+        tauto
+    · constructor
+      · assumption
+      · assumption
+
+  -- Describe g near points z₁ that are different from z₀
+  have g_near_z₁ {z₁ : ℂ} : z₁ ≠ z₀ → ∀ᶠ (z : ℂ) in nhds z₁, g z = f z / (z - z₀) ^ n := by
+    intro hz₁
+    rw [eventually_nhds_iff]
+    use {z₀.1}ᶜ
+    constructor
+    · intro y hy
+      simp at hy
+      simp [g, hy]
+    · exact ⟨isOpen_compl_singleton, hz₁⟩
+
+  -- Use g and show that it has all required properties
+  use g
+  constructor
+  · -- AnalyticOn ℂ g U
+    intro z h₁z
+    by_cases h₂z : z = z₀
+    · rw [h₂z]
+      apply AnalyticAt.congr h₁gloc
+      exact Filter.EventuallyEq.symm g_near_z₀
+    · simp_rw [eq_comm] at g_near_z₁
+      apply AnalyticAt.congr _ (g_near_z₁ h₂z)
+      apply AnalyticAt.div
+      exact hf z h₁z
+      apply AnalyticAt.pow
+      apply AnalyticAt.sub
+      apply analyticAt_id
+      apply analyticAt_const
+      simp
+      rw [sub_eq_zero]
+      tauto
+  · constructor
+    · simp [g]; tauto
+    · intro z
+      by_cases h₂z : z = z₀
+      · rw [h₂z, g_near_z₀.self_of_nhds]
+        exact h₃gloc.self_of_nhds
+      · rw [(g_near_z₁ h₂z).self_of_nhds]
+        simp [h₂z]
+        rw [div_eq_mul_inv, mul_comm, mul_assoc, inv_mul_cancel₀]
+        simp; norm_num
+        rw [sub_eq_zero]
+        tauto
+
+  -- direction ←
+  intro h
+  obtain ⟨g, h₁g, h₂g, h₃g⟩ := h
+  dsimp [AnalyticOnNhd.order]
+  rw [AnalyticAt.order_eq_nat_iff]
+  use g
+  exact ⟨h₁g z₀ z₀.2, ⟨h₂g, Filter.Eventually.of_forall h₃g⟩⟩
+
+
+theorem AnalyticOnNhd.support_of_order₁
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (hf : AnalyticOnNhd ℂ f U) :
+  Function.support hf.order = U.restrict f⁻¹' {0} := by
+  ext u
+  simp [AnalyticOnNhd.order]
+  rw [not_iff_comm, (hf u u.2).order_eq_zero_iff]
+
+
+theorem AnalyticOnNhd.eliminateZeros
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  {A : Finset U}
+  (hf : AnalyticOnNhd ℂ f U)
+  (n : U → ℕ) :
+  (∀ a ∈ A, hf.order a = n a) → ∃ (g : ℂ → ℂ), AnalyticOnNhd ℂ g U ∧ (∀ a ∈ A, g a ≠ 0) ∧ ∀ z, f z = (∏ a ∈ A, (z - a) ^ (n a)) • g z := by
+
+  apply Finset.induction (α := U) (p := fun A ↦ (∀ a ∈ A, (hf a.1 a.2).order = n a) → ∃ (g : ℂ → ℂ), AnalyticOnNhd ℂ g U ∧ (∀ a ∈ A, g a ≠ 0) ∧ ∀ z, f z = (∏ a ∈ A, (z - a) ^ (n a)) • g z)
+
+  -- case empty
+  simp
+  use f
+  simp
+  exact hf
+
+  -- case insert
+  intro b₀ B hb iHyp
+  intro hBinsert
+  obtain ⟨g₀, h₁g₀, h₂g₀, h₃g₀⟩ := iHyp (fun a ha ↦ hBinsert a (Finset.mem_insert_of_mem ha))
+
+  have : (h₁g₀ b₀ b₀.2).order = n b₀ := by
+
+    rw [← hBinsert b₀ (Finset.mem_insert_self b₀ B)]
+
+    let φ := fun z ↦ (∏ a ∈ B, (z - a.1) ^ n a)
+
+    have : f = fun z ↦ φ z * g₀ z := by
+      funext z
+      rw [h₃g₀ z]
+      rfl
+    simp_rw [this]
+
+    have h₁φ : AnalyticAt ℂ φ b₀ := by
+      dsimp [φ]
+      apply Finset.analyticAt_prod
+      intro b _
+      apply AnalyticAt.pow
+      apply AnalyticAt.sub
+      apply analyticAt_id
+      exact analyticAt_const
+
+    have h₂φ : h₁φ.order = (0 : ℕ) := by
+      rw [AnalyticAt.order_eq_nat_iff h₁φ 0]
+      use φ
+      constructor
+      · assumption
+      · constructor
+        · dsimp [φ]
+          push_neg
+          rw [Finset.prod_ne_zero_iff]
+          intro a ha
+          simp
+          have : ¬ (b₀.1 - a.1 = 0) := by
+            by_contra C
+            rw [sub_eq_zero] at C
+            rw [SetCoe.ext C] at hb
+            tauto
+          tauto
+        · simp
+
+    rw [AnalyticAt.order_mul h₁φ (h₁g₀ b₀ b₀.2)]
+
+    rw [h₂φ]
+    simp
+
+  obtain ⟨g₁, h₁g₁, h₂g₁, h₃g₁⟩ := (AnalyticOnNhd.order_eq_nat_iff h₁g₀ (n b₀)).1 this
+
+  use g₁
+  constructor
+  · exact h₁g₁
+  · constructor
+    · intro a h₁a
+      by_cases h₂a : a = b₀
+      · rwa [h₂a]
+      · let A' := Finset.mem_of_mem_insert_of_ne h₁a h₂a
+        let B' := h₃g₁ a
+        let C' := h₂g₀ a A'
+        rw [B'] at C'
+        exact right_ne_zero_of_smul C'
+    · intro z
+      let A' := h₃g₀ z
+      rw [h₃g₁ z] at A'
+      rw [A']
+      rw [← smul_assoc]
+      congr
+      simp
+      rw [Finset.prod_insert]
+      ring
+      exact hb
+
+
+theorem XX
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (hU : IsPreconnected U)
+  (h₁f : AnalyticOnNhd ℂ f U)
+  (h₂f : ∃ u ∈ U, f u ≠ 0) :
+  ∀ (hu : u ∈ U), (h₁f u hu).order.toNat = (h₁f u hu).order := by
+
+  intro hu
+  apply ENat.coe_toNat
+  by_contra C
+  rw [(h₁f u hu).order_eq_top_iff] at C
+  rw [← (h₁f u hu).frequently_zero_iff_eventually_zero] at C
+  obtain ⟨u₁, h₁u₁, h₂u₁⟩ := h₂f
+  rw [(h₁f.eqOn_zero_of_preconnected_of_frequently_eq_zero hU hu C) h₁u₁] at h₂u₁
+  tauto
+
+
+theorem discreteZeros
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (hU : IsPreconnected U)
+  (h₁f : AnalyticOnNhd ℂ f U)
+  (h₂f : ∃ u ∈ U, f u ≠ 0) :
+  DiscreteTopology ((U.restrict f)⁻¹' {0}) := by
+
+  simp_rw [← singletons_open_iff_discrete]
+  simp_rw [Metric.isOpen_singleton_iff]
+
+  intro z
+
+  let A := XX hU h₁f h₂f z.1.2
+  rw [eq_comm] at A
+  rw [AnalyticAt.order_eq_nat_iff] at A
+  obtain ⟨g, h₁g, h₂g, h₃g⟩ := A
+
+  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 ε₁ ε₂
+
+  have F := h₂ε₂ y.1 h₂y
+  have : f y = 0 := by exact y.2
+  rw [this] at F
+  simp at F
+
+  have : g y.1 ≠ 0 := by
+    exact h₁ε₁.2 y h₃y
+  simp [this] at F
+  ext
+  rw [sub_eq_zero] at F
+  tauto
+
+
+theorem finiteZeros
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (h₁U : IsPreconnected U)
+  (h₂U : IsCompact U)
+  (h₁f : AnalyticOnNhd ℂ f U)
+  (h₂f : ∃ u ∈ U, f u ≠ 0) :
+  Set.Finite (U.restrict f⁻¹' {0}) := by
+
+  have closedness : IsClosed (U.restrict f⁻¹' {0}) := by
+    apply IsClosed.preimage
+    apply continuousOn_iff_continuous_restrict.1
+    exact h₁f.continuousOn
+    exact isClosed_singleton
+
+  have : CompactSpace U := by
+    exact isCompact_iff_compactSpace.mp h₂U
+
+  apply (IsClosed.isCompact closedness).finite
+  exact discreteZeros h₁U h₁f h₂f
+
+
+theorem AnalyticOnNhdCompact.eliminateZeros
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (h₁U : IsPreconnected U)
+  (h₂U : IsCompact U)
+  (h₁f : AnalyticOnNhd ℂ f U)
+  (h₂f : ∃ u ∈ U, f u ≠ 0) :
+  ∃ (g : ℂ → ℂ) (A : Finset U), AnalyticOnNhd ℂ g U ∧ (∀ z ∈ U, g z ≠ 0) ∧ ∀ z, f z = (∏ a ∈ A, (z - a) ^ (h₁f.order a).toNat) • g z := by
+
+  let A := (finiteZeros h₁U h₂U h₁f h₂f).toFinset
+
+  let n : U → ℕ := fun z ↦ (h₁f z z.2).order.toNat
+
+  have hn : ∀ a ∈ A, (h₁f a a.2).order = n a := by
+    intro a _
+    dsimp [n, AnalyticOnNhd.order]
+    rw [eq_comm]
+    apply XX h₁U
+    exact h₂f
+
+
+  obtain ⟨g, h₁g, h₂g, h₃g⟩ := AnalyticOnNhd.eliminateZeros (A := A) h₁f n hn
+  use g
+  use A
+
+  have inter : ∀ (z : ℂ), f z = (∏ a ∈ A, (z - ↑a) ^ (h₁f (↑a) a.property).order.toNat) • g z := by
+    intro z
+    rw [h₃g z]
+
+  constructor
+  · exact h₁g
+  · constructor
+    · intro z h₁z
+      by_cases h₂z : ⟨z, h₁z⟩  ∈ ↑A.toSet
+      · exact h₂g ⟨z, h₁z⟩ h₂z
+      · have : f z ≠ 0 := by
+          by_contra C
+          have : ⟨z, h₁z⟩ ∈ ↑A.toSet := by
+            dsimp [A]
+            simp
+            exact C
+          tauto
+        rw [inter z] at this
+        exact right_ne_zero_of_smul this
+    · exact inter
+
+
+theorem AnalyticOnNhdCompact.eliminateZeros₂
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (h₁U : IsPreconnected U)
+  (h₂U : IsCompact U)
+  (h₁f : AnalyticOnNhd ℂ f U)
+  (h₂f : ∃ u ∈ U, f u ≠ 0) :
+  ∃ (g : ℂ → ℂ), AnalyticOnNhd ℂ g U ∧ (∀ z ∈ U, g z ≠ 0) ∧ ∀ z, f z = (∏ a ∈ (finiteZeros h₁U h₂U h₁f h₂f).toFinset, (z - a) ^ (h₁f.order a).toNat) • g z := by
+
+  let A := (finiteZeros h₁U h₂U h₁f h₂f).toFinset
+
+  let n : U → ℕ := fun z ↦ (h₁f z z.2).order.toNat
+
+  have hn : ∀ a ∈ A, (h₁f a a.2).order = n a := by
+    intro a _
+    dsimp [n, AnalyticOnNhd.order]
+    rw [eq_comm]
+    apply XX h₁U
+    exact h₂f
+
+  obtain ⟨g, h₁g, h₂g, h₃g⟩ := AnalyticOnNhd.eliminateZeros (A := A) h₁f n hn
+  use g
+
+  have inter : ∀ (z : ℂ), f z = (∏ a ∈ A, (z - ↑a) ^ (h₁f (↑a) a.property).order.toNat) • g z := by
+    intro z
+    rw [h₃g z]
+
+  constructor
+  · exact h₁g
+  · constructor
+    · intro z h₁z
+      by_cases h₂z : ⟨z, h₁z⟩  ∈ ↑A.toSet
+      · exact h₂g ⟨z, h₁z⟩ h₂z
+      · have : f z ≠ 0 := by
+          by_contra C
+          have : ⟨z, h₁z⟩ ∈ ↑A.toSet := by
+            dsimp [A]
+            simp
+            exact C
+          tauto
+        rw [inter z] at this
+        exact right_ne_zero_of_smul this
+    · exact h₃g
+
+
+theorem AnalyticOnNhdCompact.eliminateZeros₁
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (h₁U : IsPreconnected U)
+  (h₂U : IsCompact U)
+  (h₁f : AnalyticOnNhd ℂ f U)
+  (h₂f : ∃ u ∈ U, f u ≠ 0) :
+  ∃ (g : ℂ → ℂ), AnalyticOnNhd ℂ g U ∧ (∀ z ∈ U, g z ≠ 0) ∧ ∀ z, f z = (∏ᶠ a, (z - a) ^ (h₁f.order a).toNat) • g z := by
+
+  let A := (finiteZeros h₁U h₂U h₁f h₂f).toFinset
+
+  let n : U → ℕ := fun z ↦ (h₁f z z.2).order.toNat
+
+  have hn : ∀ a ∈ A, (h₁f a a.2).order = n a := by
+    intro a _
+    dsimp [n, AnalyticOnNhd.order]
+    rw [eq_comm]
+    apply XX h₁U
+    exact h₂f
+
+  obtain ⟨g, h₁g, h₂g, h₃g⟩ := AnalyticOnNhd.eliminateZeros (A := A) h₁f n hn
+  use g
+
+  have inter : ∀ (z : ℂ), f z = (∏ a ∈ A, (z - ↑a) ^ (h₁f (↑a) a.property).order.toNat) • g z := by
+    intro z
+    rw [h₃g z]
+
+  constructor
+  · exact h₁g
+  · constructor
+    · intro z h₁z
+      by_cases h₂z : ⟨z, h₁z⟩  ∈ ↑A.toSet
+      · exact h₂g ⟨z, h₁z⟩ h₂z
+      · have : f z ≠ 0 := by
+          by_contra C
+          have : ⟨z, h₁z⟩ ∈ ↑A.toSet := by
+            dsimp [A]
+            simp
+            exact C
+          tauto
+        rw [inter z] at this
+        exact right_ne_zero_of_smul this
+    · intro z
+
+      let φ : U → ℂ := fun a ↦ (z - ↑a) ^ (h₁f.order a).toNat
+      have hφ : Function.mulSupport φ ⊆ A := by
+        intro x hx
+        simp [φ] at hx
+        have : (h₁f.order x).toNat ≠ 0 := by
+          by_contra C
+          rw [C] at hx
+          simp at hx
+        simp [A]
+        exact AnalyticAt.supp_order_toNat (h₁f x x.2) this
+      rw [finprod_eq_prod_of_mulSupport_subset φ hφ]
+      rw [inter z]
+      rfl

Nevanlinna/leftovers/bilinear.lean

@@ -0,0 +1,77 @@
+/-
+Copyright (c) 2024 Stefan Kebekus. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Stefan Kebekus
+-/
+
+import Mathlib.Analysis.InnerProductSpace.PiL2
+
+/-!
+
+# Canoncial Elements in Tensor Powers of Real Inner Product Spaces
+
+Given an `InnerProductSpace ℝ E`, this file defines two canonical tensors, which
+are relevant when for a coordinate-free definition of differential operators
+such as the Laplacian.
+
+* `InnerProductSpace.canonicalContravariantTensor E : E ⊗[ℝ] E →ₗ[ℝ] ℝ`. This is
+  the element corresponding to the inner product.
+
+* If `E` is finite-dimensional, then `E ⊗[ℝ] E` is canonically isomorphic to its
+  dual. Accordingly, there exists an element
+  `InnerProductSpace.canonicalCovariantTensor E : E ⊗[ℝ] E` that corresponds to
+  `InnerProductSpace.canonicalContravariantTensor E` under this identification.
+
+The theorem `InnerProductSpace.canonicalCovariantTensorRepresentation` shows
+that `InnerProductSpace.canonicalCovariantTensor E` can be computed from any
+orthonormal basis `v` as `∑ i, (v i) ⊗ₜ[ℝ] (v i)`.
+
+-/
+
+open InnerProductSpace
+open TensorProduct
+
+
+noncomputable def InnerProductSpace.canonicalContravariantTensor
+  {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E]
+  : E ⊗[ℝ] E →ₗ[ℝ] ℝ := TensorProduct.lift bilinFormOfRealInner
+
+
+noncomputable def InnerProductSpace.canonicalCovariantTensor
+  (E : Type*) [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E]
+  : E ⊗[ℝ] E := ∑ i, ((stdOrthonormalBasis ℝ E) i) ⊗ₜ[ℝ] ((stdOrthonormalBasis ℝ E) i)
+
+theorem InnerProductSpace.canonicalCovariantTensorRepresentation
+  (E : Type*) [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E]
+  [Fintype ι]
+  (v : OrthonormalBasis ι ℝ E) :
+  InnerProductSpace.canonicalCovariantTensor E = ∑ i, (v i) ⊗ₜ[ℝ] (v i) := by
+
+  let w := stdOrthonormalBasis ℝ E
+  conv =>
+    right
+    arg 2
+    intro i
+    rw [← w.sum_repr' (v i)]
+  simp_rw [TensorProduct.sum_tmul, TensorProduct.tmul_sum, TensorProduct.smul_tmul_smul]
+
+  conv =>
+    right
+    rw [Finset.sum_comm]
+    arg 2
+    intro y
+    rw [Finset.sum_comm]
+    arg 2
+    intro x
+    rw [← Finset.sum_smul]
+    arg 1
+    arg 2
+    intro i
+    rw [← real_inner_comm (w x)]
+  simp_rw [OrthonormalBasis.sum_inner_mul_inner v]
+
+  have {i} : ∑ j, ⟪w i, w j⟫_ℝ • w i ⊗ₜ[ℝ] w j = w i ⊗ₜ[ℝ] w i := by
+    rw [Fintype.sum_eq_single i, orthonormal_iff_ite.1 w.orthonormal]; simp
+    intro _ _; rw [orthonormal_iff_ite.1 w.orthonormal]; simp; tauto
+  simp_rw [this]
+  rfl

Nevanlinna/leftovers/diffOp.lean

@@ -0,0 +1,104 @@
+import Mathlib.Analysis.Calculus.ContDiff.Basic
+import Mathlib.Analysis.InnerProductSpace.PiL2
+
+/-
+
+Let E, F, G be vector spaces over nontrivally normed field 𝕜, a homogeneus
+linear differential operator of order n is a map that attaches to every point e
+of E a linear evaluation
+
+{Continuous 𝕜-multilinear maps E → F in n variables} → G
+
+In other words, homogeneus linear differential operator of order n is an
+instance of the type:
+
+D : E → (ContinuousMultilinearMap 𝕜 (fun _ : Fin n ↦ E) F) →ₗ[𝕜] G
+
+Given any map f : E → F, one obtains a map D f : E → G by sending a point e to
+the evaluation (D e), applied to the n.th derivative of f at e
+
+fun e ↦ D e (iteratedFDeriv 𝕜 n f e)
+
+-/
+
+@[ext]
+class HomLinDiffOp
+  (𝕜 : Type*) [NontriviallyNormedField 𝕜]
+  (n : ℕ)
+  (E : Type*) [NormedAddCommGroup E] [NormedSpace 𝕜 E]
+  (F : Type*) [NormedAddCommGroup F] [NormedSpace 𝕜 F]
+  (G : Type*) [NormedAddCommGroup G] [NormedSpace 𝕜 G]
+where
+  tensorfield : E → ( E [×n]→L[𝕜] F) →L[𝕜] G
+--  tensorfield : E → (ContinuousMultilinearMap 𝕜 (fun _ : Fin n ↦ E) F) →ₗ[𝕜] G
+
+
+namespace HomLinDiffOp
+
+noncomputable def toFun
+  {𝕜 : Type*} [NontriviallyNormedField 𝕜]
+  {n : ℕ}
+  {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
+  {F : Type*} [NormedAddCommGroup F] [NormedSpace 𝕜 F]
+  {G : Type*} [NormedAddCommGroup G] [NormedSpace 𝕜 G]
+  (o : HomLinDiffOp 𝕜 n E F G)
+  : (E → F) → (E → G) :=
+  fun f z ↦ o.tensorfield z (iteratedFDeriv 𝕜 n f z)
+
+
+noncomputable def Laplace
+  {𝕜 : Type*} [RCLike 𝕜]
+  {n : ℕ}
+  : HomLinDiffOp 𝕜 2 (EuclideanSpace 𝕜 (Fin n)) 𝕜 𝕜
+  where
+  tensorfield := by
+    intro _
+
+    let v := stdOrthonormalBasis 𝕜 (EuclideanSpace 𝕜 (Fin n))
+    rw [finrank_euclideanSpace_fin] at v
+
+    exact {
+      toFun := fun f' ↦ ∑ i, f' ![v i, v i]
+      map_add' := by
+        intro f₁ f₂
+        exact Finset.sum_add_distrib
+      map_smul' := by
+        intro m f
+        exact Eq.symm (Finset.mul_sum Finset.univ (fun i ↦ f ![v i, v i]) m)
+      cont := by
+        simp
+        apply continuous_finset_sum
+        intro i _
+        exact ContinuousEvalConst.continuous_eval_const ![v i, v i]
+    }
+
+
+noncomputable def Gradient
+  {𝕜 : Type*} [RCLike 𝕜]
+  {n : ℕ}
+  : HomLinDiffOp 𝕜 1 (EuclideanSpace 𝕜 (Fin n)) 𝕜 (EuclideanSpace 𝕜 (Fin n))
+  where
+  tensorfield := by
+    intro _
+
+    let v := stdOrthonormalBasis 𝕜 (EuclideanSpace 𝕜 (Fin n))
+    rw [finrank_euclideanSpace_fin] at v
+
+    exact {
+      toFun := fun f' ↦ ∑ i, (f' ![v i]) • (v i)
+      map_add' := by
+        intro f₁ f₂
+        simp; simp_rw [add_smul, Finset.sum_add_distrib]
+      map_smul' := by
+        intro m f
+        simp; simp_rw [Finset.smul_sum, ←smul_assoc,smul_eq_mul]
+      cont := by
+        simp
+        apply continuous_finset_sum
+        intro i _
+        apply Continuous.smul
+        exact ContinuousEvalConst.continuous_eval_const ![v i]
+        exact continuous_const
+    }
+
+end HomLinDiffOp

Nevanlinna/leftovers/holomorphic.lean

@@ -0,0 +1,176 @@
+import Mathlib.Analysis.Complex.TaylorSeries
+import Nevanlinna.cauchyRiemann
+
+variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
+variable {F : Type*} [NormedAddCommGroup F] [NormedSpace ℂ F]
+variable {G : Type*} [NormedAddCommGroup G] [NormedSpace ℂ G]
+
+def HolomorphicAt (f : E → F) (x : E) : Prop :=
+  ∃ s ∈ nhds x, ∀ z ∈ s, DifferentiableAt ℂ f z
+
+
+theorem HolomorphicAt_iff
+  {f : E → F}
+  {x : E} :
+  HolomorphicAt f x ↔ ∃ s :
+  Set E, IsOpen s ∧ x ∈ s ∧ (∀ z ∈ s, DifferentiableAt ℂ f z) := by
+  constructor
+  · intro hf
+    obtain ⟨t, h₁t, h₂t⟩ := hf
+    obtain ⟨s, h₁s, h₂s, h₃s⟩ := mem_nhds_iff.1 h₁t
+    use s
+    constructor
+    · assumption
+    · constructor
+      · assumption
+      · intro z hz
+        exact h₂t z (h₁s hz)
+  · intro hyp
+    obtain ⟨s, h₁s, h₂s, hf⟩ := hyp
+    use s
+    constructor
+    · apply (IsOpen.mem_nhds_iff h₁s).2 h₂s
+    · assumption
+
+
+theorem HolomorphicAt_analyticAt
+  [CompleteSpace F]
+  {f : ℂ → F}
+  {x : ℂ} :
+  HolomorphicAt f x → AnalyticAt ℂ f x := by
+  intro hf
+  obtain ⟨s, h₁s, h₂s, h₃s⟩ := HolomorphicAt_iff.1 hf
+  apply DifferentiableOn.analyticAt (s := s)
+  intro z hz
+  apply DifferentiableAt.differentiableWithinAt
+  apply h₃s
+  exact hz
+  exact IsOpen.mem_nhds h₁s h₂s
+
+
+theorem HolomorphicAt_differentiableAt
+  {f : E → F}
+  {x : E} :
+  HolomorphicAt f x →  DifferentiableAt ℂ f x := by
+  intro hf
+  obtain ⟨s, _, h₂s, h₃s⟩ := HolomorphicAt_iff.1 hf
+  exact h₃s x h₂s
+
+
+theorem HolomorphicAt_isOpen
+  (f : E → F) :
+  IsOpen { x : E | HolomorphicAt f x } := by
+
+  rw [← subset_interior_iff_isOpen]
+  intro x hx
+  simp at hx
+  obtain ⟨s, h₁s, h₂s, h₃s⟩ := HolomorphicAt_iff.1 hx
+  use s
+  constructor
+  · simp
+    constructor
+    · exact h₁s
+    · intro x hx
+      simp
+      use s
+      constructor
+      · exact IsOpen.mem_nhds h₁s hx
+      · exact h₃s
+  · exact h₂s
+
+
+theorem HolomorphicAt_comp
+  {g : E → F}
+  {f : F → G}
+  {z : E}
+  (hf : HolomorphicAt f (g z))
+  (hg : HolomorphicAt g z) :
+  HolomorphicAt (f ∘ g) z := by
+  obtain ⟨UE, h₁UE, h₂UE⟩ := hg
+  obtain ⟨UF, h₁UF, h₂UF⟩ := hf
+  use UE ∩ g⁻¹' UF
+  constructor
+  · simp
+    constructor
+    · assumption
+    · apply ContinuousAt.preimage_mem_nhds
+      apply (h₂UE z (mem_of_mem_nhds h₁UE)).continuousAt
+      assumption
+  · intro x hx
+    apply DifferentiableAt.comp
+    apply h₂UF
+    exact hx.2
+    apply h₂UE
+    exact hx.1
+
+
+theorem HolomorphicAt_neg
+  {f : E → F}
+  {z : E}
+  (hf : HolomorphicAt f z) :
+  HolomorphicAt (-f) z := by
+  obtain ⟨UF, h₁UF, h₂UF⟩ := hf
+  use UF
+  constructor
+  · assumption
+  · intro z hz
+    apply differentiableAt_neg_iff.mp
+    simp
+    exact h₂UF z hz
+
+
+theorem HolomorphicAt_contDiffAt
+  [CompleteSpace F]
+  {f : ℂ → F}
+  {z : ℂ}
+  (hf : HolomorphicAt f z) :
+  ContDiffAt ℝ 2 f z := by
+
+  let t := {x | HolomorphicAt f x}
+  have ht : IsOpen t := HolomorphicAt_isOpen f
+  have hz : z ∈ t := by exact hf
+
+  -- ContDiffAt ℝ 2 f z
+  apply ContDiffOn.contDiffAt _ ((IsOpen.mem_nhds_iff ht).2 hz)
+  suffices h : ContDiffOn ℂ 2 f t from by
+    apply ContDiffOn.restrict_scalars ℝ h
+  apply DifferentiableOn.contDiffOn _ ht
+  intro w hw
+  apply DifferentiableAt.differentiableWithinAt
+  exact HolomorphicAt_differentiableAt hw
+
+
+theorem CauchyRiemann'₅
+  {f : ℂ → F}
+  {z : ℂ}
+  (h : DifferentiableAt ℂ f z) :
+  partialDeriv ℝ Complex.I f z = Complex.I • partialDeriv ℝ 1 f z := by
+  unfold partialDeriv
+
+  conv =>
+    left
+    rw [DifferentiableAt.fderiv_restrictScalars ℝ h]
+    simp
+    rw [← mul_one Complex.I]
+    rw [← smul_eq_mul]
+  conv =>
+    right
+    right
+    rw [DifferentiableAt.fderiv_restrictScalars ℝ h]
+  simp
+
+theorem CauchyRiemann'₆
+  {f : ℂ → F}
+  {z : ℂ}
+  (h : HolomorphicAt f z) :
+  partialDeriv ℝ Complex.I f =ᶠ[nhds z] Complex.I • partialDeriv ℝ 1 f := by
+
+  obtain ⟨s, h₁s, hz, h₂f⟩ := HolomorphicAt_iff.1 h
+
+  apply Filter.eventuallyEq_iff_exists_mem.2
+  use s
+  constructor
+  · exact IsOpen.mem_nhds h₁s hz
+  · intro w hw
+    apply CauchyRiemann'₅
+    exact h₂f w hw

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/leftovers/specialFunctions_Integral_log.lean

@@ -0,0 +1,65 @@
+import Mathlib.Analysis.SpecialFunctions.Integrals
+import Mathlib.Analysis.SpecialFunctions.Log.NegMulLog
+import Mathlib.MeasureTheory.Integral.CircleIntegral
+import Mathlib.MeasureTheory.Measure.Restrict
+
+open scoped Interval Topology
+open Real Filter MeasureTheory intervalIntegral
+
+-- The following theorem was suggested by Gareth Ma on Zulip
+
+
+theorem logInt
+  {t : ℝ}
+  (ht : 0 < t) :
+  ∫ x in (0 : ℝ)..t, log x = t * log t - t := by
+  rw [← integral_add_adjacent_intervals (b := 1)]
+  trans (-1) + (t * log t - t + 1)
+  · congr
+    · -- ∫ x in 0..1, log x = -1, same proof as before
+      rw [integral_eq_sub_of_hasDerivAt_of_tendsto (f := fun x ↦ x * log x - x) (fa := 0) (fb := -1)]
+      · simp
+      · simp
+      · intro x hx
+        norm_num at hx
+        convert (hasDerivAt_mul_log hx.left.ne.symm).sub (hasDerivAt_id x) using 1
+        norm_num
+      · rw [← neg_neg log]
+        apply IntervalIntegrable.neg
+        apply intervalIntegrable_deriv_of_nonneg (g := fun x ↦ -(x * log x - x))
+        · exact (continuous_mul_log.continuousOn.sub continuous_id.continuousOn).neg
+        · intro x hx
+          norm_num at hx
+          convert ((hasDerivAt_mul_log hx.left.ne.symm).sub (hasDerivAt_id x)).neg using 1
+          norm_num
+        · intro x hx
+          norm_num at hx
+          rw [Pi.neg_apply, Left.nonneg_neg_iff]
+          exact (log_nonpos_iff hx.left).mpr hx.right.le
+      · have := tendsto_log_mul_rpow_nhds_zero zero_lt_one
+        simp_rw [rpow_one, mul_comm] at this
+        -- tendsto_nhdsWithin_of_tendsto_nhds should be under Tendsto namespace
+        convert this.sub (tendsto_nhdsWithin_of_tendsto_nhds tendsto_id)
+        norm_num
+      · rw [(by simp : -1 = 1 * log 1 - 1)]
+        apply tendsto_nhdsWithin_of_tendsto_nhds
+        exact (continuousAt_id.mul (continuousAt_log one_ne_zero)).sub continuousAt_id
+    · -- ∫ x in 1..t, log x = t * log t + 1, just use integral_log_of_pos
+      rw [integral_log_of_pos zero_lt_one ht]
+      norm_num
+  · abel
+  · -- log is integrable on [[0, 1]]
+    rw [← neg_neg log]
+    apply IntervalIntegrable.neg
+    apply intervalIntegrable_deriv_of_nonneg (g := fun x ↦ -(x * log x - x))
+    · exact (continuous_mul_log.continuousOn.sub continuous_id.continuousOn).neg
+    · intro x hx
+      norm_num at hx
+      convert ((hasDerivAt_mul_log hx.left.ne.symm).sub (hasDerivAt_id x)).neg using 1
+      norm_num
+    · intro x hx
+      norm_num at hx
+      rw [Pi.neg_apply, Left.nonneg_neg_iff]
+      exact (log_nonpos_iff hx.left).mpr hx.right.le
+  · -- log is integrable on [[0, t]]
+    simp [Set.mem_uIcc, ht]

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

@@ -0,0 +1,102 @@
+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]
+variable {F : Type*} [NormedAddCommGroup F] [NormedSpace 𝕜 F]
+variable {G : Type*} [NormedAddCommGroup G] [NormedSpace 𝕜 G]
+variable {G' : Type*} [NormedAddCommGroup G'] [NormedSpace 𝕜 G']
+variable {f f₀ f₁ g : E → F}
+variable {f' f₀' f₁' g' : E →L[𝕜] F}
+variable (e : E →L[𝕜] F)
+variable {x : E}
+variable {s t : Set E}
+variable {L L₁ L₂ : Filter E}
+
+variable {R : Type*} [Semiring R] [Module R F] [SMulCommClass 𝕜 R F] [ContinuousConstSMul R F]
+
+
+-- import Mathlib.Analysis.Calculus.FDeriv.Add
+
+@[fun_prop]
+theorem Differentiable.const_smul' (h : Differentiable 𝕜 f) (c : R) :
+    Differentiable 𝕜 (c • f) := by
+  have : c • f = fun x ↦ c • f x := rfl
+  rw [this]
+  exact Differentiable.const_smul h c
+
+
+-- Mathlib.Analysis.Calculus.ContDiff.Basic
+
+theorem ContDiff.const_smul' {f : E → F} (c : R) (hf : ContDiff 𝕜 n f) :
+    ContDiff 𝕜 n (c • f) := by
+  have : c • f = fun x ↦ c • f x := rfl
+  rw [this]
+  exact ContDiff.const_smul c hf
+
+
+
+open Topology Filter
+
+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

@@ -0,0 +1,492 @@
+import Mathlib.Analysis.Analytic.Meromorphic
+import Nevanlinna.analyticAt
+import Nevanlinna.divisor
+
+
+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 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

@@ -0,0 +1,394 @@
+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
+
+
+noncomputable def MeromorphicOn.divisor
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (hf : MeromorphicOn f U) :
+  Divisor U where
+
+  toFun := by
+    intro z
+    if hz : z ∈ U then
+      exact ((hf z hz).order.untop' 0 : ℤ)
+    else
+      exact 0
+
+  supportInU := by
+    intro z hz
+    simp at hz
+    by_contra h₂z
+    simp [h₂z] at hz
+
+  locallyFiniteInU := by
+    intro z hz
+
+    apply eventually_nhdsWithin_iff.2
+    rw [eventually_nhds_iff]
+
+    rcases MeromorphicAt.eventually_eq_zero_or_eventually_ne_zero (hf z hz) with h|h
+    · 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_cases h₃y : y ∈ U
+        · simp [h₃y]
+          right
+          rw [MeromorphicAt.order_eq_top_iff (hf y h₃y)]
+          rw [eventually_nhdsWithin_iff]
+          rw [eventually_nhds_iff]
+          use N ∩ {z}ᶜ
+          constructor
+          · intro x h₁x _
+            exact h₁N x h₁x.1 h₁x.2
+          · constructor
+            · exact IsOpen.inter h₂N isOpen_compl_singleton
+            · exact Set.mem_inter h₁y h₂y
+        · simp [h₃y]
+      · tauto
+
+    · let A := (hf z hz).eventually_analyticAt
+      let B := Filter.eventually_and.2 ⟨h, A⟩
+      rw [eventually_nhdsWithin_iff, eventually_nhds_iff] at B
+      obtain ⟨N, h₁N, h₂N, h₃N⟩ := B
+      use N
+      constructor
+      · intro y h₁y h₂y
+        by_cases h₃y : y ∈ U
+        · simp [h₃y]
+          left
+          rw [(h₁N y h₁y h₂y).2.meromorphicAt_order]
+          let D := (h₁N y h₁y h₂y).2.order_eq_zero_iff.2
+          let C := (h₁N y h₁y h₂y).1
+          let E := D C
+          rw [E]
+          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

@@ -1,6 +1,8 @@
 import Mathlib.Analysis.Calculus.FDeriv.Basic
 import Mathlib.Analysis.Calculus.FDeriv.Symmetric
 import Mathlib.Analysis.Calculus.ContDiff.Basic
+import Mathlib.Topology.Basic
+import Mathlib.Topology.Defs.Filter
 
 
 variable {𝕜 : Type*} [NontriviallyNormedField 𝕜]
@@ -14,12 +16,40 @@ noncomputable def partialDeriv : E → (E → F) → (E → F) :=
   fun v ↦ (fun f ↦ (fun w ↦ fderiv 𝕜 f w v))
 
 
-theorem partialDeriv_smul₁ {f : E → F} {a : 𝕜} {v : E} : partialDeriv 𝕜 (a • v) f = a • partialDeriv 𝕜 v f := by
+theorem partialDeriv_eventuallyEq'
+  {f₁ f₂ : E → F}
+  {x : E}
+  (h : f₁ =ᶠ[nhds x] f₂) :
+  ∀ v : E, partialDeriv 𝕜 v f₁ =ᶠ[nhds x] partialDeriv 𝕜 v f₂ := by
+  unfold partialDeriv
+  intro v
+  apply Filter.EventuallyEq.comp₂
+  exact Filter.EventuallyEq.fderiv h
+  simp
+
+
+theorem partialDeriv_eventuallyEq
+  {f₁ f₂ : E → F}
+  {x : E}
+  (h : f₁ =ᶠ[nhds x] f₂) :
+  ∀ v : E, partialDeriv 𝕜 v f₁ x = partialDeriv 𝕜 v f₂ x := by
+  unfold partialDeriv
+  rw [Filter.EventuallyEq.fderiv_eq h]
+  exact fun v => rfl
+
+
+theorem partialDeriv_smul₁
+  {f : E → F}
+  {a : 𝕜}
+  {v : E} :
+  partialDeriv 𝕜 (a • v) f = a • partialDeriv 𝕜 v f := by
   unfold partialDeriv
   conv =>
     left
     intro w
     rw [map_smul]
+  funext w
+  simp
 
 
 theorem partialDeriv_add₁ {f : E → F} {v₁ v₂ : E} : partialDeriv 𝕜 (v₁ + v₂) f = (partialDeriv 𝕜 v₁ f) + (partialDeriv 𝕜 v₂ f) := by
@@ -28,23 +58,39 @@ theorem partialDeriv_add₁ {f : E → F} {v₁ v₂ : E} : partialDeriv 𝕜 (v
     left
     intro w
     rw [map_add]
+  funext w
+  simp
 
 
-theorem partialDeriv_smul₂ {f : E → F} {a : 𝕜} {v : E} (h : Differentiable 𝕜 f) : partialDeriv 𝕜 v (a • f) = a • partialDeriv 𝕜 v f := by
+theorem partialDeriv_smul₂ {f : E → F} {a : 𝕜} {v : E} : partialDeriv 𝕜 v (a • f) = a • partialDeriv 𝕜 v f := by
   unfold partialDeriv
-
+  funext w
   have : a • f = fun y ↦ a • f y := by rfl
   rw [this]
-
-  conv =>
-    left
-    intro w
-    rw [fderiv_const_smul (h w)]
+  by_cases ha : a = 0
+  · rw [ha]
+    simp
+  · by_cases hf : DifferentiableAt 𝕜 f w
+    · rw [fderiv_const_smul hf]
+      simp
+    · have : ¬DifferentiableAt 𝕜 (fun y => a • f y) w := by
+        by_contra contra
+        let ZZ := DifferentiableAt.const_smul contra a⁻¹
+        have : (fun y => a⁻¹ • a • f y) = f := by
+          funext i
+          rw [← smul_assoc, smul_eq_mul, mul_comm, mul_inv_cancel₀ ha]
+          simp
+        rw [this] at ZZ
+        exact hf ZZ
+      simp
+      rw [fderiv_zero_of_not_differentiableAt hf]
+      rw [fderiv_zero_of_not_differentiableAt this]
+      simp
 
 
-theorem partialDeriv_add₂ {f₁ f₂ : E → F} {v : E} (h₁ : Differentiable 𝕜 f₁)  (h₂ : Differentiable 𝕜 f₂) : partialDeriv 𝕜 v (f₁ + f₂) = (partialDeriv 𝕜 v f₁) + (partialDeriv 𝕜 v f₂) := by
+theorem partialDeriv_add₂ {f₁ f₂ : E → F} (h₁ : Differentiable 𝕜 f₁) (h₂ : Differentiable 𝕜 f₂) : ∀ v : E, partialDeriv 𝕜 v (f₁ + f₂) = (partialDeriv 𝕜 v f₁) + (partialDeriv 𝕜 v f₂) := by
   unfold partialDeriv
-
+  intro v
   have : f₁ + f₂ = fun y ↦ f₁ y + f₂ y := by rfl
   rw [this]
   conv =>
@@ -52,26 +98,138 @@ theorem partialDeriv_add₂ {f₁ f₂ : E → F} {v : E} (h₁ : Differentiable
     intro w
     left
     rw [fderiv_add (h₁ w) (h₂ w)]
+  funext w
+  simp
 
 
-theorem partialDeriv_compContLin {f : E → F} {l : F →L[𝕜] G} {v : E} (h : Differentiable 𝕜 f) : partialDeriv 𝕜 v (l ∘ f) = l ∘ partialDeriv 𝕜 v f := by
+theorem partialDeriv_add₂_differentiableAt
+  {f₁ f₂ : E → F}
+  {v : E}
+  {x : E}
+  (h₁ : DifferentiableAt 𝕜 f₁ x)
+  (h₂ : DifferentiableAt 𝕜 f₂ x) :
+  partialDeriv 𝕜 v (f₁ + f₂) x = (partialDeriv 𝕜 v f₁) x + (partialDeriv 𝕜 v f₂) x := by
+
+  unfold partialDeriv
+  have : f₁ + f₂ = fun y ↦ f₁ y + f₂ y := by rfl
+  rw [this]
+  rw [fderiv_add h₁ h₂]
+  rfl
+
+
+theorem partialDeriv_add₂_contDiffAt
+  {f₁ f₂ : E → F}
+  {v : E}
+  {x : E}
+  (h₁ : ContDiffAt 𝕜 1 f₁ x)
+  (h₂ : ContDiffAt 𝕜 1 f₂ x) :
+  partialDeriv 𝕜 v (f₁ + f₂) =ᶠ[nhds x] (partialDeriv 𝕜 v f₁) + (partialDeriv 𝕜 v f₂) := by
+
+  obtain ⟨f₁', u₁, hu₁, _, hf₁'⟩ := contDiffAt_one_iff.1 h₁
+  obtain ⟨f₂', u₂, hu₂, _, hf₂'⟩ := contDiffAt_one_iff.1 h₂
+
+  apply Filter.eventuallyEq_iff_exists_mem.2
+  use u₁ ∩ u₂
+  constructor
+  · exact Filter.inter_mem hu₁ hu₂
+  · intro x hx
+    simp
+    apply partialDeriv_add₂_differentiableAt 𝕜
+    exact (hf₁' x (Set.mem_of_mem_inter_left hx)).differentiableAt
+    exact (hf₂' x (Set.mem_of_mem_inter_right hx)).differentiableAt
+
+
+theorem partialDeriv_sub₂ {f₁ f₂ : E → F} (h₁ : Differentiable 𝕜 f₁) (h₂ : Differentiable 𝕜 f₂) : ∀ v : E, partialDeriv 𝕜 v (f₁ - f₂) = (partialDeriv 𝕜 v f₁) - (partialDeriv 𝕜 v f₂) := by
+  unfold partialDeriv
+  intro v
+  have : f₁ - f₂ = fun y ↦ f₁ y - f₂ y := by rfl
+  rw [this]
+  conv =>
+    left
+    intro w
+    left
+    rw [fderiv_sub (h₁ w) (h₂ w)]
+  funext w
+  simp
+
+
+theorem partialDeriv_sub₂_differentiableAt
+  {f₁ f₂ : E → F}
+  {v : E}
+  {x : E}
+  (h₁ : DifferentiableAt 𝕜 f₁ x)
+  (h₂ : DifferentiableAt 𝕜 f₂ x) :
+  partialDeriv 𝕜 v (f₁ - f₂) x = (partialDeriv 𝕜 v f₁) x - (partialDeriv 𝕜 v f₂) x := by
+
+  unfold partialDeriv
+  have : f₁ - f₂ = fun y ↦ f₁ y - f₂ y := by rfl
+  rw [this]
+  rw [fderiv_sub h₁ h₂]
+  rfl
+
+
+theorem partialDeriv_sub₂_contDiffAt
+  {f₁ f₂ : E → F}
+  {v : E}
+  {x : E}
+  (h₁ : ContDiffAt 𝕜 1 f₁ x)
+  (h₂ : ContDiffAt 𝕜 1 f₂ x) :
+  partialDeriv 𝕜 v (f₁ - f₂) =ᶠ[nhds x] (partialDeriv 𝕜 v f₁) - (partialDeriv 𝕜 v f₂) := by
+
+  obtain ⟨f₁', u₁, hu₁, _, hf₁'⟩ := contDiffAt_one_iff.1 h₁
+  obtain ⟨f₂', u₂, hu₂, _, hf₂'⟩ := contDiffAt_one_iff.1 h₂
+
+  apply Filter.eventuallyEq_iff_exists_mem.2
+  use u₁ ∩ u₂
+  constructor
+  · exact Filter.inter_mem hu₁ hu₂
+  · intro x hx
+    simp
+    apply partialDeriv_sub₂_differentiableAt 𝕜
+    exact (hf₁' x (Set.mem_of_mem_inter_left hx)).differentiableAt
+    exact (hf₂' x (Set.mem_of_mem_inter_right hx)).differentiableAt
+
+
+theorem partialDeriv_compContLin
+  {f : E → F}
+  {l : F →L[𝕜] G}
+  {v : E}
+  (h : Differentiable 𝕜 f) :
+  partialDeriv 𝕜 v (l ∘ f) = l ∘ partialDeriv 𝕜 v f := by
   unfold partialDeriv
 
   conv =>
     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
 
 
+theorem partialDeriv_compCLE {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_contDiff {n : ℕ} {f : E → F} (h : ContDiff 𝕜 (n + 1) f) : ∀ v : E, ContDiff 𝕜 n (partialDeriv 𝕜 v f) := by
   unfold partialDeriv
   intro v
@@ -90,12 +248,17 @@ theorem partialDeriv_contDiff {n : ℕ} {f : E → F} (h : ContDiff 𝕜 (n + 1)
   exact contDiff_const
 
 
-theorem partialDeriv_contDiffAt {n : ℕ} {f : E → F} {x : E} (h : ContDiffAt 𝕜 (n + 1) f x) : ∀ v : E, ContDiffAt 𝕜 n (partialDeriv 𝕜 v f) x := by
+theorem partialDeriv_contDiffAt
+  {n : ℕ}
+  {f : E → F}
+  {x : E}
+  (h : ContDiffAt 𝕜 (n + 1) f x) :
+  ∀ v : E, ContDiffAt 𝕜 n (partialDeriv 𝕜 v f) x := by
 
   unfold partialDeriv
   intro v
 
-  let eval_at_v : (E →L[𝕜] F) →L[𝕜] F := 
+  let eval_at_v : (E →L[𝕜] F) →L[𝕜] F :=
   {
     toFun := fun l ↦ l v
     map_add' := by simp
@@ -118,27 +281,110 @@ 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
 
 
-theorem partialDeriv_eventuallyEq {f₁ f₂ : E → F} {x : E} (h : f₁ =ᶠ[nhds x] f₂) : ∀ v : E, partialDeriv 𝕜 v f₁ x = partialDeriv 𝕜 v f₂ x := by
+lemma partialDeriv_fderivOn
+  {s : Set E}
+  {f : E → F}
+  (hs : IsOpen s)
+  (hf : ContDiffOn 𝕜 2 f s) (a b : E) :
+  ∀ z ∈ s, fderiv 𝕜 (fderiv 𝕜 f) z b a = partialDeriv 𝕜 b (partialDeriv 𝕜 a f) z := by
+
+  intro z hz
   unfold partialDeriv
-  rw [Filter.EventuallyEq.fderiv_eq h]
-  exact fun v => rfl
+  rw [fderiv_clm_apply]
+  · simp
+  · convert DifferentiableOn.differentiableAt _ (IsOpen.mem_nhds hs hz)
+    apply ContDiffOn.differentiableOn _ (Preorder.le_refl 1)
+    rw [← one_add_one_eq_two] at hf
+    rw [contDiffOn_succ_iff_fderiv_of_isOpen hs] at hf
+    exact hf.2.2
+  · simp
+
+
+lemma partialDeriv_fderivAt
+  {z : E}
+  {f : E → F}
+  (hf : ContDiffAt 𝕜 2 f z)
+  (a b : E) :
+  fderiv 𝕜 (fderiv 𝕜 f) z b a = partialDeriv 𝕜 b (partialDeriv 𝕜 a f) z := by
+
+  unfold partialDeriv
+  rw [fderiv_clm_apply]
+  simp
+
+  -- DifferentiableAt 𝕜 (fun w => fderiv 𝕜 f w) z
+  obtain ⟨f', ⟨u, h₁u, h₂u⟩, hf' ⟩ := contDiffAt_succ_iff_hasFDerivAt.1 hf
+  have t₁ : (fun w ↦ fderiv 𝕜 f w) =ᶠ[nhds z] f' := by
+    apply Filter.eventuallyEq_iff_exists_mem.2
+    use u
+    constructor
+    · exact h₁u
+    · intro x hx
+      exact HasFDerivAt.fderiv (h₂u x hx)
+  rw [Filter.EventuallyEq.differentiableAt_iff t₁]
+  exact hf'.differentiableAt le_rfl
+
+  -- DifferentiableAt 𝕜 (fun w => a) z
+  exact differentiableAt_const a
 
 
 section restrictScalars
 
-variable (𝕜 : Type*) [NontriviallyNormedField 𝕜]
-variable {𝕜' : Type*} [NontriviallyNormedField 𝕜'] [NormedAlgebra 𝕜 𝕜']
-variable {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E] [NormedSpace 𝕜' E]
-variable [IsScalarTower 𝕜 𝕜' E]
-variable {F : Type*} [NormedAddCommGroup F] [NormedSpace 𝕜 F] [NormedSpace 𝕜' F]
-variable [IsScalarTower 𝕜 𝕜' F]
---variable {f : E → F}
+theorem partialDeriv_smul'₂
+  (𝕜 : Type*) [NontriviallyNormedField 𝕜]
+  {𝕜' : Type*} [NontriviallyNormedField 𝕜'] [NormedAlgebra 𝕜 𝕜']
+  {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
+  {F : Type*} [NormedAddCommGroup F] [NormedSpace 𝕜 F] [NormedSpace 𝕜' F]
+  [IsScalarTower 𝕜 𝕜' F]
+  {f : E → F} {a : 𝕜'} {v : E} :
+  partialDeriv 𝕜 v (a • f) = a • partialDeriv 𝕜 v f := by
 
-theorem partialDeriv_restrictScalars {f : E → F} {v : E} :
+  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 partialDeriv_restrictScalars
+  (𝕜 : Type*) [NontriviallyNormedField 𝕜]
+  {𝕜' : Type*} [NontriviallyNormedField 𝕜'] [NormedAlgebra 𝕜 𝕜']
+  {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E] [NormedSpace 𝕜' E]
+  [IsScalarTower 𝕜 𝕜' E]
+  {F : Type*} [NormedAddCommGroup F] [NormedSpace 𝕜 F] [NormedSpace 𝕜' F]
+  [IsScalarTower 𝕜 𝕜' F]
+  {f : E → F} {v : E} :
   Differentiable 𝕜' f → partialDeriv 𝕜 v f = partialDeriv 𝕜' v f := by
   intro hf
   unfold partialDeriv
@@ -167,10 +413,68 @@ 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 (Submonoid.oneLE.proof_2 ℕ∞)
+      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₂
 
   rw [← partialDeriv_fderiv ℝ h z v₂ v₁]
   rw [derivSymm]
   rw [partialDeriv_fderiv ℝ h z v₁ v₂]
+
+
+theorem partialDeriv_commOn
+  {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
+  {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F]
+  {s : Set E}
+  {f : E → F}
+  (hs : IsOpen s)
+  (h : ContDiffOn ℝ 2 f s) :
+  ∀ v₁ v₂ : E, ∀ z ∈ s, partialDeriv ℝ v₁ (partialDeriv ℝ v₂ f) z = partialDeriv ℝ v₂ (partialDeriv ℝ v₁ f) z := by
+
+  intro v₁ v₂ z hz
+
+  have derivSymm :
+    (fderiv ℝ (fun w => fderiv ℝ f w) z) v₁ v₂ = (fderiv ℝ (fun w => fderiv ℝ f w) z) v₂ v₁ := by
+
+    let f' := fderiv ℝ f
+    have h₀1 : ∀ y ∈ s, HasFDerivAt f (f' y) y := by
+      intro y hy
+      apply DifferentiableAt.hasFDerivAt
+      apply DifferentiableOn.differentiableAt _ (IsOpen.mem_nhds hs hy)
+      apply h.differentiableOn one_le_two
+
+    let f'' := (fderiv ℝ f' z)
+    have h₁ : HasFDerivAt f' f'' z := by
+      apply DifferentiableAt.hasFDerivAt
+      apply DifferentiableOn.differentiableAt _ (IsOpen.mem_nhds hs hz)
+      apply ContDiffOn.differentiableOn _ (Preorder.le_refl 1)
+      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
+      use s
+
+    exact second_derivative_symmetric_of_eventually h₀' h₁ v₁ v₂
+
+  rw [← partialDeriv_fderivOn ℝ hs h v₂ v₁ z hz]
+  rw [derivSymm]
+  rw [← partialDeriv_fderivOn ℝ hs h v₁ v₂ z hz]
+
+
+theorem partialDeriv_commAt
+  {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
+  {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F]
+  {z : E}
+  {f : E → F}
+  (h : ContDiffAt ℝ 2 f z) :
+  ∀ v₁ v₂ : E, partialDeriv ℝ v₁ (partialDeriv ℝ v₂ f) z = partialDeriv ℝ v₂ (partialDeriv ℝ v₁ f) z := by
+
+  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₂
+  exact partialDeriv_commOn hv₂ (hu₂.mono hv₁) v₁ v₂ z hv₃

Nevanlinna/periodic_integrability.lean

@@ -0,0 +1,101 @@
+import Mathlib.MeasureTheory.Integral.Periodic
+
+
+theorem periodic_integrability₁
+  {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E]
+  {f : ℝ → E}
+  {t T : ℝ}
+  {n : ℕ}
+  (h₁f : Function.Periodic f T)
+  (h₂f : IntervalIntegrable f MeasureTheory.volume t (t + T)) :
+  IntervalIntegrable f MeasureTheory.volume t (t + n * T) := by
+  induction' n with n hn
+  simp
+  apply IntervalIntegrable.trans (b := t + n * T)
+  exact hn
+
+  let A := IntervalIntegrable.comp_sub_right h₂f (n * T)
+  have : f = fun x ↦ f (x - n * T) := by simp [Function.Periodic.sub_nat_mul_eq h₁f n]
+  simp_rw [← this] at A
+  have : (t + T + ↑n * T) = (t + ↑(n + 1) * T) := by simp; ring
+  simp_rw [this] at A
+  exact A
+
+theorem periodic_integrability₂
+  {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E]
+  {f : ℝ → E}
+  {t T : ℝ}
+  {n : ℕ}
+  (h₁f : Function.Periodic f T)
+  (h₂f : IntervalIntegrable f MeasureTheory.volume t (t + T)) :
+  IntervalIntegrable f MeasureTheory.volume (t - n * T) t := by
+  induction' n with n hn
+  simp
+  --
+  apply IntervalIntegrable.trans (b := t - n * T)
+  --
+  have A := IntervalIntegrable.comp_add_right h₂f (((n + 1): ℕ) * T)
+
+  have : f = fun x ↦ f (x + ((n + 1) : ℕ) * T) := by
+    funext x
+    have : x = x + ↑(n + 1) * T - ↑(n + 1) * T := by ring
+    nth_rw 1 [this]
+    rw [Function.Periodic.sub_nat_mul_eq h₁f]
+  simp_rw [← this] at A
+  have : (t + T - ↑(n + 1) * T) = (t - ↑n * T) := by simp; ring
+  simp_rw [this] at A
+  exact A
+  --
+  exact hn
+
+
+theorem periodic_integrability₃
+  {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E]
+  {f : ℝ → E}
+  {t T : ℝ}
+  {n₁ n₂ : ℕ}
+  (h₁f : Function.Periodic f T)
+  (h₂f : IntervalIntegrable f MeasureTheory.volume t (t + T)) :
+  IntervalIntegrable f MeasureTheory.volume (t - n₁ * T) (t + n₂ * T) := by
+  apply IntervalIntegrable.trans (b := t)
+  exact periodic_integrability₂ h₁f h₂f
+  exact periodic_integrability₁ h₁f h₂f
+
+
+theorem periodic_integrability4
+  {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℝ E]
+  {f : ℝ → E}
+  {t T : ℝ}
+  {a₁ a₂ : ℝ}
+  (h₁f : Function.Periodic f T)
+  (hT : 0 < T)
+  (h₂f : IntervalIntegrable f MeasureTheory.volume t (t + T)) :
+  IntervalIntegrable f MeasureTheory.volume a₁ a₂ := by
+
+  obtain ⟨n₁, hn₁⟩ : ∃ n₁ : ℕ, t - n₁ * T ≤ min a₁ a₂ := by
+    obtain ⟨n₁, hn₁⟩ := exists_nat_ge ((t -min a₁ a₂) / T)
+    use n₁
+    rw [sub_le_iff_le_add]
+    rw [div_le_iff₀ hT] at hn₁
+    rw [sub_le_iff_le_add] at hn₁
+    rw [add_comm]
+    exact hn₁
+  obtain ⟨n₂, hn₂⟩ : ∃ n₂ : ℕ, max a₁ a₂ ≤ t + n₂ * T := by
+    obtain ⟨n₂, hn₂⟩ := exists_nat_ge ((max a₁ a₂ - t) / T)
+    use n₂
+    rw [← sub_le_iff_le_add]
+    rw [div_le_iff₀ hT] at hn₂
+    linarith
+
+  have : Set.uIcc a₁ a₂ ⊆ Set.uIcc (t - n₁ * T) (t + n₂ * T) := by
+    apply Set.uIcc_subset_uIcc_iff_le.mpr
+    constructor
+    · calc min (t - ↑n₁ * T) (t + ↑n₂ * T)
+      _ ≤ (t - ↑n₁ * T) := by exact min_le_left (t - ↑n₁ * T) (t + ↑n₂ * T)
+      _ ≤ min a₁ a₂ := by exact hn₁
+    · calc max a₁ a₂
+      _ ≤ t + n₂ * T := by exact hn₂
+      _ ≤ max (t - ↑n₁ * T) (t + ↑n₂ * T) := by exact le_max_right (t - ↑n₁ * T) (t + ↑n₂ * T)
+
+  apply IntervalIntegrable.mono_set _ this
+  exact periodic_integrability₃ h₁f h₂f

Nevanlinna/specialFunctions_CircleIntegral_affine.lean

@@ -0,0 +1,533 @@
+import Mathlib.MeasureTheory.Integral.Periodic
+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
+open Real Filter MeasureTheory intervalIntegral
+
+
+
+-- Lemmas for the circleMap
+
+lemma l₀ {x₁ x₂ : ℝ} : (circleMap 0 1 x₁) * (circleMap 0 1 x₂) = circleMap 0 1 (x₁+x₂) := by
+  dsimp [circleMap]
+  simp
+  rw [add_mul, Complex.exp_add]
+
+lemma l₁ {x : ℝ} : ‖circleMap 0 1 x‖ = 1 := by
+  rw [Complex.norm_eq_abs, abs_circleMap_zero]
+  simp
+
+lemma l₂ {x : ℝ} : ‖(circleMap 0 1 x) - a‖ = ‖1 - (circleMap 0 1 (-x)) * a‖ := by
+  calc ‖(circleMap 0 1 x) - a‖
+  _ = 1 * ‖(circleMap 0 1 x) - a‖ := by
+    exact Eq.symm (one_mul ‖circleMap 0 1 x - a‖)
+  _ = ‖(circleMap 0 1 (-x))‖ * ‖(circleMap 0 1 x) - a‖ := by
+    rw [l₁]
+  _ = ‖(circleMap 0 1 (-x)) * ((circleMap 0 1 x) - a)‖ := by
+    exact Eq.symm (NormedField.norm_mul' (circleMap 0 1 (-x)) (circleMap 0 1 x - a))
+  _ = ‖(circleMap 0 1 (-x)) * (circleMap 0 1 x) - (circleMap 0 1 (-x)) * a‖ := by
+    rw [mul_sub]
+  _ = ‖(circleMap 0 1 0) - (circleMap 0 1 (-x)) * a‖ := by
+    rw [l₀]
+    simp
+  _ = ‖1 - (circleMap 0 1 (-x)) * a‖ := by
+    congr
+    dsimp [circleMap]
+    simp
+
+
+-- Integral of log ‖circleMap 0 1 x - a‖, for ‖a‖ < 1.
+
+lemma int'₀
+  {a : ℂ}
+  (ha : ‖a‖ ≠ 1) :
+  IntervalIntegrable (fun x ↦ log ‖circleMap 0 1 x - a‖) volume 0 (2 * π) := by
+  apply Continuous.intervalIntegrable
+  apply Continuous.log
+  fun_prop
+  simp
+  intro x
+  by_contra h₁a
+  rw [← h₁a] at ha
+  simp at ha
+
+
+lemma int₀
+  {a : ℂ}
+  (ha : a ∈ Metric.ball 0 1) :
+  ∫ (x : ℝ) in (0)..2 * π, log ‖circleMap 0 1 x - a‖ = 0 := by
+
+  by_cases h₁a : a = 0
+  · -- case: a = 0
+    rw [h₁a]
+    simp
+
+  -- case: a ≠ 0
+  simp_rw [l₂]
+  have {x : ℝ} : log ‖1 - circleMap 0 1 (-x) * a‖ = (fun w ↦ log ‖1 - circleMap 0 1 (w) * a‖) (-x) := by rfl
+  conv =>
+    left
+    arg 1
+    intro x
+    rw [this]
+  rw [intervalIntegral.integral_comp_neg ((fun w ↦ log ‖1 - circleMap 0 1 (w) * a‖))]
+
+  let f₁ := fun w ↦ log ‖1 - circleMap 0 1 w * a‖
+  have {x : ℝ} : log ‖1 - circleMap 0 1 x * a‖ = f₁ (x + 2 * π) := by
+    dsimp [f₁]
+    congr 4
+    let A := periodic_circleMap 0 1 x
+    simp at A
+    exact id (Eq.symm A)
+  conv =>
+    left
+    arg 1
+    intro x
+    rw [this]
+  rw [intervalIntegral.integral_comp_add_right f₁ (2 * π)]
+  simp
+  dsimp [f₁]
+
+  let ρ := ‖a‖⁻¹
+  have hρ : 1 < ρ := by
+    apply one_lt_inv_iff₀.mpr
+    constructor
+    · exact norm_pos_iff.mpr h₁a
+    · exact mem_ball_zero_iff.mp ha
+
+  let F := fun z ↦ log ‖1 - z * a‖
+
+  have hf : ∀ x ∈ Metric.ball 0 ρ, HarmonicAt F x := by
+    intro x hx
+    apply logabs_of_holomorphicAt_is_harmonic
+    apply Differentiable.holomorphicAt
+    fun_prop
+    apply sub_ne_zero_of_ne
+    by_contra h
+    have : ‖x * a‖ < 1 := by
+      calc ‖x * a‖
+      _ = ‖x‖ * ‖a‖ := by exact NormedField.norm_mul' x a
+      _ < ρ * ‖a‖ := by
+        apply (mul_lt_mul_right _).2
+        exact mem_ball_zero_iff.mp hx
+        exact norm_pos_iff.mpr h₁a
+      _ = 1 := by
+        dsimp [ρ]
+        apply inv_mul_cancel₀
+        exact (AbsoluteValue.ne_zero_iff Complex.abs).mpr h₁a
+    rw [← h] at this
+    simp at this
+
+  let A := harmonic_meanValue ρ 1 zero_lt_one hρ hf
+  dsimp [F] at A
+  simp at A
+  exact A
+
+
+-- 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
+    intro hx
+    rw [log_mul, log_pow]
+    rfl
+    exact Ne.symm (NeZero.ne' 4)
+    apply pow_ne_zero 2
+    apply (fun a => Ne.symm (ne_of_lt a))
+    exact sin_pos_of_mem_Ioo hx
+
+
+  have t₂ : Set.EqOn (fun y ↦ log (4 * sin y ^ 2)) (fun y ↦ log 4 + 2 * log (sin y)) (Set.Ioo 0 π) := by
+    intro x hx
+    simp
+    rw [t₁ hx]
+
+  rw [intervalIntegral.integral_congr_volume pi_pos t₂]
+  rw [intervalIntegral.integral_add]
+  rw [intervalIntegral.integral_const_mul]
+  simp
+  rw [integral_log_sin₂]
+  have : (4 : ℝ) = 2 * 2 := by norm_num
+  rw [this, log_mul]
+  ring
+  norm_num
+  norm_num
+  -- IntervalIntegrable (fun x => log 4) volume 0 π
+  simp
+  -- IntervalIntegrable (fun x => 2 * log (sin x)) volume 0 π
+  apply IntervalIntegrable.const_mul
+  exact intervalIntegrable_log_sin
+
+lemma logAffineHelper {x : ℝ} : log ‖circleMap 0 1 x - 1‖ = log (4 * sin (x / 2) ^ 2) / 2 := by
+  dsimp [Complex.abs]
+  rw [log_sqrt (Complex.normSq_nonneg (circleMap 0 1 x - 1))]
+  congr
+  calc Complex.normSq (circleMap 0 1 x - 1)
+  _ = (cos x - 1) * (cos x - 1) + sin x * sin x := by
+    dsimp [circleMap]
+    rw [Complex.normSq_apply]
+    simp
+  _ = sin x ^ 2 + cos x ^ 2 + 1 - 2 * cos x := by
+    ring
+  _ = 2 - 2 * cos x := by
+    rw [sin_sq_add_cos_sq]
+    norm_num
+  _ = 2 - 2 * cos (2 * (x / 2)) := by
+    rw [← mul_div_assoc]
+    congr; norm_num
+  _ = 4 - 4 * cos (x / 2) ^ 2 := by
+    rw [cos_two_mul]
+    ring
+  _ = 4 * sin (x / 2) ^ 2 := by
+    nth_rw 1 [← mul_one 4, ← sin_sq_add_cos_sq (x / 2)]
+    ring
+
+lemma int'₁ : -- Integrability of log ‖circleMap 0 1 x - 1‖
+  IntervalIntegrable (fun x ↦ log ‖circleMap 0 1 x - 1‖) volume 0 (2 * π) := by
+
+  simp_rw [logAffineHelper]
+  apply IntervalIntegrable.div_const
+  rw [← IntervalIntegrable.comp_mul_left_iff (c := 2) (Ne.symm (NeZero.ne' 2))]
+  simp
+
+  have h₁ : Set.EqOn (fun x => log (4 * sin x ^ 2)) (fun x => log 4 + 2 * log (sin x)) (Set.Ioo 0 π) := by
+    intro x hx
+    simp [log_mul (Ne.symm (NeZero.ne' 4)), log_pow, ne_of_gt (sin_pos_of_mem_Ioo hx)]
+  rw [IntervalIntegrable.integral_congr_Ioo pi_nonneg h₁]
+  apply IntervalIntegrable.add
+  simp
+  apply IntervalIntegrable.const_mul
+  exact intervalIntegrable_log_sin
+
+lemma int''₁ : -- Integrability of log ‖circleMap 0 1 x - 1‖ for arbitrary intervals
+  ∀ (t₁ t₂ : ℝ), IntervalIntegrable (fun x ↦ log ‖circleMap 0 1 x - 1‖) volume t₁ t₂ := by
+  intro t₁ t₂
+
+  apply periodic_integrability4 (T := 2 * π) (t := 0)
+  --
+  have : (fun x => log ‖circleMap 0 1 x - 1‖) = (fun x => log ‖x - 1‖) ∘ (circleMap 0 1) := rfl
+  rw [this]
+  apply Function.Periodic.comp
+  exact periodic_circleMap 0 1
+  --
+  exact two_pi_pos
+  --
+  rw [zero_add]
+  exact int'₁
+
+lemma int₁ :
+  ∫ x in (0)..(2 * π), log ‖circleMap 0 1 x - 1‖ = 0 := by
+
+  simp_rw [logAffineHelper]
+  simp
+
+  have : ∫ (x : ℝ) in (0)..2 * π, log (4 * sin (x / 2) ^ 2) =  2 * ∫ (x : ℝ) in (0)..π, log (4 * sin x ^ 2) := by
+    have : 1 = 2 * (2 : ℝ)⁻¹ := by exact Eq.symm (mul_inv_cancel_of_invertible 2)
+    nth_rw 1 [← one_mul (∫ (x : ℝ) in (0)..2 * π, log (4 * sin (x / 2) ^ 2))]
+    rw [← mul_inv_cancel_of_invertible 2, mul_assoc]
+    let f := fun y ↦ log (4 * sin y ^ 2)
+    have {x : ℝ} : log (4 * sin (x / 2) ^ 2) = f (x / 2) := by simp
+    conv =>
+      left
+      right
+      right
+      arg 1
+      intro x
+      rw [this]
+    rw [intervalIntegral.inv_mul_integral_comp_div 2]
+    simp
+  rw [this]
+  simp
+  exact int₁₁
+
+
+-- Integral of log ‖circleMap 0 1 x - a‖, for ‖a‖ = 1
+
+-- integrability
+lemma int'₂
+  {a : ℂ}
+  (ha : ‖a‖ = 1) :
+  IntervalIntegrable (fun x ↦ log ‖circleMap 0 1 x - a‖) volume 0 (2 * π) := by
+
+  simp_rw [l₂]
+  have {x : ℝ} : log ‖1 - circleMap 0 1 (-x) * a‖ = (fun w ↦ log ‖1 - circleMap 0 1 (w) * a‖) (-x) := by rfl
+  conv =>
+    arg 1
+    intro x
+    rw [this]
+  rw [IntervalIntegrable.iff_comp_neg]
+
+  let f₁ := fun w ↦ log ‖1 - circleMap 0 1 w * a‖
+  have {x : ℝ} : log ‖1 - circleMap 0 1 x * a‖ = f₁ (x + 2 * π) := by
+    dsimp [f₁]
+    congr 4
+    let A := periodic_circleMap 0 1 x
+    simp at A
+    exact id (Eq.symm A)
+  conv =>
+    arg 1
+    intro x
+    arg 0
+    intro w
+    rw [this]
+  simp
+  have : 0 = 2 * π - 2 * π := by ring
+  rw [this]
+  have : -(2 * π ) = 0 - 2 * π := by ring
+  rw [this]
+  apply IntervalIntegrable.comp_add_right _ (2 * π) --f₁ (2 * π)
+  dsimp [f₁]
+
+  have : ∃ ζ, a = circleMap 0 1 ζ := by
+    apply Set.exists_range_iff.mp
+    use a
+    simp
+    exact ha
+  obtain ⟨ζ, hζ⟩ := this
+  rw [hζ]
+  simp_rw [l₀]
+
+  have : 2 * π  = (2 * π + ζ) - ζ := by ring
+  rw [this]
+  have : 0 = ζ - ζ := by ring
+  rw [this]
+  have : (fun w => log (Complex.abs (1 - circleMap 0 1 (w + ζ)))) = fun x ↦ (fun w ↦ log (Complex.abs (1 - circleMap 0 1 (w)))) (x + ζ) := rfl
+  rw [this]
+  apply IntervalIntegrable.comp_add_right (f := (fun w ↦ log (Complex.abs (1 - circleMap 0 1 (w))))) _ ζ
+
+  have : Function.Periodic (fun x ↦ log (Complex.abs (1 - circleMap 0 1 x))) (2 * π) := by
+    have : (fun x ↦ log (Complex.abs (1 - circleMap 0 1 x))) = ( (fun x ↦ log (Complex.abs (1 - x))) ∘ (circleMap 0 1) ) := by rfl
+    rw [this]
+    apply Function.Periodic.comp
+    exact periodic_circleMap 0 1
+
+  let A := int''₁ (2 * π + ζ) ζ
+  have {x : ℝ} : ‖circleMap 0 1 x - 1‖ = Complex.abs (1 - circleMap 0 1 x) := AbsoluteValue.map_sub Complex.abs (circleMap 0 1 x) 1
+  simp_rw [this] at A
+  exact A
+
+-- integral
+lemma int₂
+  {a : ℂ}
+  (ha : ‖a‖ = 1) :
+  ∫ x in (0)..(2 * π), log ‖circleMap 0 1 x - a‖ = 0 := by
+
+  simp_rw [l₂]
+  have {x : ℝ} : log ‖1 - circleMap 0 1 (-x) * a‖ = (fun w ↦ log ‖1 - circleMap 0 1 (w) * a‖) (-x) := by rfl
+  conv =>
+    left
+    arg 1
+    intro x
+    rw [this]
+  rw [intervalIntegral.integral_comp_neg ((fun w ↦ log ‖1 - circleMap 0 1 (w) * a‖))]
+
+  let f₁ := fun w ↦ log ‖1 - circleMap 0 1 w * a‖
+  have {x : ℝ} : log ‖1 - circleMap 0 1 x * a‖ = f₁ (x + 2 * π) := by
+    dsimp [f₁]
+    congr 4
+    let A := periodic_circleMap 0 1 x
+    simp at A
+    exact id (Eq.symm A)
+  conv =>
+    left
+    arg 1
+    intro x
+    rw [this]
+  rw [intervalIntegral.integral_comp_add_right f₁ (2 * π)]
+  simp
+  dsimp [f₁]
+
+  have : ∃ ζ, a = circleMap 0 1 ζ := by
+    apply Set.exists_range_iff.mp
+    use a
+    simp
+    exact ha
+  obtain ⟨ζ, hζ⟩ := this
+  rw [hζ]
+  simp_rw [l₀]
+
+  rw [intervalIntegral.integral_comp_add_right (f := fun x ↦ log (Complex.abs (1 - circleMap 0 1 (x))))]
+
+  have : Function.Periodic (fun x ↦ log (Complex.abs (1 - circleMap 0 1 x))) (2 * π) := by
+    have : (fun x ↦ log (Complex.abs (1 - circleMap 0 1 x))) = ( (fun x ↦ log (Complex.abs (1 - x))) ∘ (circleMap 0 1) ) := by rfl
+    rw [this]
+    apply Function.Periodic.comp
+    exact periodic_circleMap 0 1
+
+  let A := Function.Periodic.intervalIntegral_add_eq this ζ 0
+  simp at A
+  simp
+  rw [add_comm]
+  rw [A]
+
+  have {x : ℝ} : log (Complex.abs (1 - circleMap 0 1 x)) = log ‖circleMap 0 1 x - 1‖ := by
+    rw [← AbsoluteValue.map_neg Complex.abs]
+    simp
+  simp_rw [this]
+  exact int₁
+
+-- integral
+lemma int₃
+  {a : ℂ}
+  (ha : a ∈ Metric.closedBall 0 1) :
+  ∫ x in (0)..(2 * π), log ‖circleMap 0 1 x - a‖ = 0 := by
+  by_cases h₁a : a ∈ Metric.ball 0 1
+  · exact int₀ h₁a
+  · apply int₂
+    simp at ha
+    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

@@ -0,0 +1,376 @@
+import Mathlib.Analysis.SpecialFunctions.Integrals
+import Mathlib.Analysis.SpecialFunctions.Log.NegMulLog
+import Mathlib.Analysis.Convex.SpecificFunctions.Deriv
+
+open scoped Interval Topology
+open Real Filter MeasureTheory intervalIntegral
+
+
+
+lemma logsinBound : ∀ x ∈ (Set.Icc 0 1), ‖(log ∘ sin) x‖ ≤ ‖log ((π / 2)⁻¹ * x)‖ := by
+
+  intro x hx
+  by_cases h'x : x = 0
+  · rw [h'x]; simp
+
+  -- Now handle the case where x ≠ 0
+  have l₀ : log ((π / 2)⁻¹ * x) ≤ 0 := by
+    apply log_nonpos
+    apply mul_nonneg
+    apply le_of_lt
+    apply inv_pos.2
+    apply div_pos
+    exact pi_pos
+    exact zero_lt_two
+    apply (Set.mem_Icc.1 hx).1
+    simp
+    apply mul_le_one₀
+    rw [div_le_one pi_pos]
+    exact two_le_pi
+    exact (Set.mem_Icc.1 hx).1
+    exact (Set.mem_Icc.1 hx).2
+
+  have l₁ : 0 ≤ sin x := by
+    apply sin_nonneg_of_nonneg_of_le_pi (Set.mem_Icc.1 hx).1
+    trans (1 : ℝ)
+    exact (Set.mem_Icc.1 hx).2
+    trans π / 2
+    exact one_le_pi_div_two
+    norm_num [pi_nonneg]
+  have l₂ : log (sin x) ≤ 0 := log_nonpos l₁ (sin_le_one x)
+
+  simp only [norm_eq_abs, Function.comp_apply]
+  rw [abs_eq_neg_self.2 l₀]
+  rw [abs_eq_neg_self.2 l₂]
+  simp only [neg_le_neg_iff, ge_iff_le]
+
+  have l₃ : x ∈ (Set.Ioi 0) := by
+    simp
+    exact lt_of_le_of_ne (Set.mem_Icc.1 hx).1 ( fun a => h'x (id (Eq.symm a)) )
+
+  have l₅ : 0 < (π / 2)⁻¹ * x := by
+    apply mul_pos
+    apply inv_pos.2
+    apply div_pos pi_pos zero_lt_two
+    exact l₃
+
+  have : ∀ x ∈ (Set.Icc 0 (π / 2)), (π / 2)⁻¹ * x ≤ sin x := by
+    intro x hx
+
+    have i₀ : 0 ∈ Set.Icc 0 π :=
+      Set.left_mem_Icc.mpr pi_nonneg
+    have i₁ : π / 2 ∈ Set.Icc 0 π :=
+      Set.mem_Icc.mpr ⟨div_nonneg pi_nonneg zero_le_two, half_le_self pi_nonneg⟩
+
+    have i₂ : 0 ≤ 1 - (π / 2)⁻¹ * x := by
+      rw [sub_nonneg]
+      calc (π / 2)⁻¹ * x
+      _ ≤ (π / 2)⁻¹ * (π / 2) := by
+        apply mul_le_mul_of_nonneg_left
+        exact (Set.mem_Icc.1 hx).2
+        apply inv_nonneg.mpr (div_nonneg pi_nonneg zero_le_two)
+      _ = 1 := by
+        apply inv_mul_cancel₀
+        apply div_ne_zero_iff.mpr
+        constructor
+        · exact pi_ne_zero
+        · exact Ne.symm (NeZero.ne' 2)
+
+    have i₃ : 0 ≤ (π / 2)⁻¹ * x := by
+      apply mul_nonneg
+      apply inv_nonneg.2
+      apply div_nonneg
+      exact pi_nonneg
+      exact zero_le_two
+      exact (Set.mem_Icc.1 hx).1
+
+    have i₄ : 1 - (π / 2)⁻¹ * x + (π / 2)⁻¹ * x = 1 := by ring
+
+    let B := strictConcaveOn_sin_Icc.concaveOn.2 i₀ i₁ i₂ i₃ i₄
+    simp [Real.sin_pi_div_two] at B
+    rw [(by ring_nf; rw [mul_inv_cancel₀ pi_ne_zero, one_mul] : 2 / π * x * (π / 2) = x)] at B
+    simpa
+
+  apply log_le_log l₅
+  apply this
+  apply Set.mem_Icc.mpr
+  constructor
+  · exact le_of_lt l₃
+  · trans 1
+    exact (Set.mem_Icc.1 hx).2
+    exact one_le_pi_div_two
+
+
+lemma intervalIntegrable_log_sin₁ : IntervalIntegrable (log ∘ sin) volume 0 1 := by
+
+  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))
+    · exact (continuous_mul_log.continuousOn.sub continuous_id.continuousOn).neg
+    · intro x hx
+      norm_num at hx
+      convert ((hasDerivAt_mul_log hx.left.ne.symm).sub (hasDerivAt_id x)).neg using 1
+      norm_num
+    · intro x hx
+      norm_num at hx
+      rw [Pi.neg_apply, Left.nonneg_neg_iff]
+      exact (log_nonpos_iff hx.left).mpr hx.right.le
+
+
+  have int_log : IntervalIntegrable (fun x ↦ ‖log ((π / 2)⁻¹ * x)‖) volume 0 1 := by
+
+    have A := IntervalIntegrable.comp_mul_right int_log (π / 2)⁻¹
+    simp only [norm_eq_abs] at A
+    conv =>
+      arg 1
+      intro x
+      rw [mul_comm]
+    simp only [norm_eq_abs]
+    apply IntervalIntegrable.mono A
+    simp
+    trans Set.Icc 0 (π / 2)
+    exact Set.Icc_subset_Icc (Preorder.le_refl 0) one_le_pi_div_two
+    exact Set.Icc_subset_uIcc
+    exact Preorder.le_refl volume
+
+  apply IntervalIntegrable.mono_fun' (g := fun x ↦ ‖log ((π / 2)⁻¹ * x)‖)
+  exact int_log
+
+  -- AEStronglyMeasurable (log ∘ sin) (volume.restrict (Ι 0 1))
+  apply ContinuousOn.aestronglyMeasurable
+  apply ContinuousOn.comp (t := Ι 0 1)
+  apply ContinuousOn.mono (s := {0}ᶜ)
+  exact continuousOn_log
+  intro x hx
+  by_contra contra
+  simp at contra
+  rw [contra, Set.left_mem_uIoc] at hx
+  linarith
+  exact continuousOn_sin
+
+  -- Set.MapsTo sin (Ι 0 1) (Ι 0 1)
+  rw [Set.uIoc_of_le (zero_le_one' ℝ)]
+  exact fun x hx ↦ ⟨sin_pos_of_pos_of_le_one hx.1 hx.2, sin_le_one x⟩
+
+  -- MeasurableSet (Ι 0 1)
+  exact measurableSet_uIoc
+
+  -- (fun x => ‖(log ∘ sin) x‖) ≤ᶠ[ae (volume.restrict (Ι 0 1))] ‖log‖
+  dsimp [EventuallyLE]
+  rw [MeasureTheory.ae_restrict_iff]
+  apply MeasureTheory.ae_of_all
+  intro x hx
+  have : x ∈ Set.Icc 0 1 := by
+    simp
+    simp at hx
+    constructor
+    · exact le_of_lt hx.1
+    · exact hx.2
+  let A := logsinBound x this
+  simp only [Function.comp_apply, norm_eq_abs] at A
+  exact A
+
+  apply measurableSet_le
+  apply Measurable.comp'
+  exact continuous_abs.measurable
+  exact Measurable.comp' measurable_log continuous_sin.measurable
+  -- Measurable fun a => |log ((π / 2)⁻¹ * a)|
+  apply Measurable.comp'
+  exact continuous_abs.measurable
+  apply Measurable.comp'
+  exact measurable_log
+  exact measurable_const_mul (π / 2)⁻¹
+
+lemma intervalIntegrable_log_sin₂ : IntervalIntegrable (log ∘ sin) volume 0 (π / 2) := by
+
+  apply IntervalIntegrable.trans (b := 1)
+  exact intervalIntegrable_log_sin₁
+
+  -- IntervalIntegrable (log ∘ sin) volume 1 (π / 2)
+  apply ContinuousOn.intervalIntegrable
+  apply ContinuousOn.comp continuousOn_log continuousOn_sin
+  intro x hx
+  rw [Set.uIcc_of_le, Set.mem_Icc] at hx
+  have : 0 < sin x := by
+    apply Real.sin_pos_of_pos_of_lt_pi
+    · calc 0
+      _ < 1 := Real.zero_lt_one
+      _ ≤ x := hx.1
+    · calc x
+      _ ≤ π / 2 := hx.2
+      _ < π := div_two_lt_of_pos pi_pos
+  by_contra h₁x
+  simp at h₁x
+  rw [h₁x] at this
+  simp at this
+  exact one_le_pi_div_two
+
+theorem intervalIntegrable_log_sin : IntervalIntegrable (log ∘ sin) volume 0 π := by
+  apply IntervalIntegrable.trans (b := π / 2)
+  exact intervalIntegrable_log_sin₂
+  -- IntervalIntegrable (log ∘ sin) volume (π / 2) π
+  let A := IntervalIntegrable.comp_sub_left intervalIntegrable_log_sin₂ π
+  simp at A
+  let B := IntervalIntegrable.symm A
+  have : π - π / 2 = π / 2 := by linarith
+  rwa [this] at B
+
+theorem intervalIntegrable_log_cos : IntervalIntegrable (log ∘ cos) volume 0 (π / 2) := by
+  let A := IntervalIntegrable.comp_sub_left intervalIntegrable_log_sin₂ (π / 2)
+  simp only [Function.comp_apply, sub_zero, sub_self] at A
+  simp_rw [sin_pi_div_two_sub] at A
+  have : (fun x => log (cos x)) = log ∘ cos := rfl
+  apply IntervalIntegrable.symm
+  rwa [← this]
+
+
+theorem intervalIntegral.integral_congr_volume
+  {E : Type u_3} [NormedAddCommGroup E] [NormedSpace ℝ E]
+  {f : ℝ → E}
+  {g : ℝ → E}
+  {a : ℝ}
+  {b : ℝ}
+  (h₀ : a < b)
+  (h₁ : Set.EqOn f g (Set.Ioo a b)) :
+  ∫ (x : ℝ) in a..b, f x = ∫ (x : ℝ) in a..b, g x := by
+
+  apply intervalIntegral.integral_congr_ae
+  rw [MeasureTheory.ae_iff]
+  apply nonpos_iff_eq_zero.1
+  push_neg
+  have : {x | x ∈ Ι a b ∧ f x ≠ g x} ⊆ {b} := by
+    intro x hx
+    have t₂ : x ∈ Ι a b \ Set.Ioo a b := by
+      constructor
+      · exact hx.1
+      · by_contra H
+        exact hx.2 (h₁ H)
+    rw [Set.uIoc_of_le (le_of_lt h₀)] at t₂
+    rw [Set.Ioc_diff_Ioo_same h₀] at t₂
+    assumption
+  calc volume {a_1 | a_1 ∈ Ι a b ∧ f a_1 ≠ g a_1}
+  _ ≤ volume {b} := volume.mono this
+  _ = 0 := volume_singleton
+
+
+theorem IntervalIntegrable.integral_congr_Ioo
+  {E : Type u_3} [NormedAddCommGroup E] [NormedSpace ℝ E]
+  {f g : ℝ → E}
+  {a b : ℝ}
+  (hab : a ≤ b)
+  (hfg : Set.EqOn f g (Set.Ioo a b)) :
+  IntervalIntegrable f volume a b ↔ IntervalIntegrable g volume a b := by
+
+  rw [intervalIntegrable_iff_integrableOn_Ioo_of_le hab]
+  rw [MeasureTheory.integrableOn_congr_fun hfg measurableSet_Ioo]
+  rw [← intervalIntegrable_iff_integrableOn_Ioo_of_le hab]
+
+
+
+lemma integral_log_sin₀ : ∫ (x : ℝ) in (0)..π, log (sin x) = 2 * ∫ (x : ℝ) in (0)..(π / 2), log (sin x) := by
+  rw [← intervalIntegral.integral_add_adjacent_intervals (a := 0) (b := π / 2) (c := π)]
+  conv =>
+    left
+    right
+    arg 1
+    intro x
+    rw [← sin_pi_sub]
+  rw [intervalIntegral.integral_comp_sub_left (fun x ↦ log (sin x)) π]
+  have : π - π / 2 = π / 2 := by linarith
+  rw [this]
+  simp
+  ring
+  -- IntervalIntegrable (fun x => log (sin x)) volume 0 (π / 2)
+  exact intervalIntegrable_log_sin₂
+  -- IntervalIntegrable (fun x => log (sin x)) volume (π / 2) π
+  apply intervalIntegrable_log_sin.mono_set
+  rw [Set.uIcc_of_le, Set.uIcc_of_le]
+  apply Set.Icc_subset_Icc_left
+  linarith [pi_pos]
+  linarith [pi_pos]
+  linarith [pi_pos]
+
+
+lemma integral_log_sin₁ : ∫ (x : ℝ) in (0)..(π / 2), log (sin x) = -log 2 * π/2 := by
+
+  have t₁ {x : ℝ} : x ∈ Set.Ioo 0 (π / 2) → log (sin (2 * x)) = log 2 + log (sin x) + log (cos x) := by
+    intro hx
+    simp at hx
+
+    rw [sin_two_mul x, log_mul, log_mul]
+    exact Ne.symm (NeZero.ne' 2)
+    -- sin x ≠ 0
+    apply (fun a => Ne.symm (ne_of_lt a))
+    apply sin_pos_of_mem_Ioo
+    constructor
+    · exact hx.1
+    · linarith [pi_pos, hx.2]
+    -- 2 * sin x ≠ 0
+    simp
+    apply (fun a => Ne.symm (ne_of_lt a))
+    apply sin_pos_of_mem_Ioo
+    constructor
+    · exact hx.1
+    · linarith [pi_pos, hx.2]
+    -- cos x ≠ 0
+    apply (fun a => Ne.symm (ne_of_lt a))
+    apply cos_pos_of_mem_Ioo
+    constructor
+    · linarith [pi_pos, hx.1]
+    · exact hx.2
+
+  have t₂ : Set.EqOn (fun y ↦ log (sin y)) (fun y ↦ log (sin (2 * y)) - log 2 - log (cos y)) (Set.Ioo 0 (π / 2)) := by
+    intro x hx
+    simp
+    rw [t₁ hx]
+    ring
+
+  rw [intervalIntegral.integral_congr_volume _ t₂]
+  rw [intervalIntegral.integral_sub, intervalIntegral.integral_sub]
+  rw [intervalIntegral.integral_const]
+  rw [intervalIntegral.integral_comp_mul_left (c := 2) (f := fun x ↦ log (sin x))]
+  simp
+  have : 2 * (π / 2) = π := by linarith
+  rw [this]
+  rw [integral_log_sin₀]
+
+  have : ∫ (x : ℝ) in (0)..(π / 2), log (sin x) = ∫ (x : ℝ) in (0)..(π / 2), log (cos x) := by
+    conv =>
+      right
+      arg 1
+      intro x
+      rw [← sin_pi_div_two_sub]
+    rw [intervalIntegral.integral_comp_sub_left (fun x ↦ log (sin x)) (π / 2)]
+    simp
+  rw [← this]
+  simp
+  linarith
+
+  exact Ne.symm (NeZero.ne' 2)
+  -- IntervalIntegrable (fun x => log (sin (2 * x))) volume 0 (π / 2)
+  let A := intervalIntegrable_log_sin.comp_mul_left 2
+  simp at A
+  assumption
+  -- IntervalIntegrable (fun x => log 2) volume 0 (π / 2)
+  simp
+  -- IntervalIntegrable (fun x => log (sin (2 * x)) - log 2) volume 0 (π / 2)
+  apply IntervalIntegrable.sub
+  -- -- IntervalIntegrable (fun x => log (sin (2 * x))) volume 0 (π / 2)
+  let A := intervalIntegrable_log_sin.comp_mul_left 2
+  simp at A
+  assumption
+  -- -- IntervalIntegrable (fun x => log 2) volume 0 (π / 2)
+  simp
+  -- -- IntervalIntegrable (fun x => log (cos x)) volume 0 (π / 2)
+  exact intervalIntegrable_log_cos
+  --
+  linarith [pi_pos]
+
+
+lemma integral_log_sin₂ : ∫ (x : ℝ) in (0)..π, log (sin x) = -log 2 * π := by
+  rw [integral_log_sin₀, integral_log_sin₁]
+  ring

Nevanlinna/stronglyMeromorphicAt.lean

@@ -0,0 +1,513 @@
+import Mathlib.Analysis.Analytic.Meromorphic
+import Mathlib.Algebra.Order.AddGroupWithTop
+import Nevanlinna.analyticAt
+import Nevanlinna.mathlibAddOn
+import Nevanlinna.meromorphicAt
+
+
+open Topology
+
+
+/- Strongly MeromorphicAt -/
+def StronglyMeromorphicAt
+  (f : ℂ → ℂ)
+  (z₀ : ℂ) :=
+  (∀ᶠ (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 : ℂ → ℂ}
+  {z₀ : ℂ}
+  (hf : StronglyMeromorphicAt f z₀) :
+  MeromorphicAt f z₀ := by
+  rcases hf with h|h
+  · use 0; simp
+    rw [analyticAt_congr h]
+    exact analyticAt_const
+  · obtain ⟨n, g, h₁g, _, h₃g⟩ := h
+    rw [meromorphicAt_congr' h₃g]
+    apply MeromorphicAt.smul
+    apply MeromorphicAt.zpow
+    apply MeromorphicAt.sub
+    apply MeromorphicAt.id
+    apply MeromorphicAt.const
+    exact AnalyticAt.meromorphicAt h₁g
+
+
+/- Strongly MeromorphicAt of non-negative order is analytic -/
+theorem StronglyMeromorphicAt.analytic
+  {f : ℂ → ℂ}
+  {z₀ : ℂ}
+  (h₁f : StronglyMeromorphicAt f z₀)
+  (h₂f : 0 ≤ h₁f.meromorphicAt.order):
+  AnalyticAt ℂ f z₀ := by
+  let h₁f' := h₁f
+  rcases h₁f' with h|h
+  · rw [analyticAt_congr h]
+    exact analyticAt_const
+  · obtain ⟨n, g, h₁g, h₂g, h₃g⟩ := h
+    rw [analyticAt_congr h₃g]
+
+    have : h₁f.meromorphicAt.order = n := by
+      rw [MeromorphicAt.order_eq_int_iff]
+      use g
+      constructor
+      · exact h₁g
+      · constructor
+        · exact h₂g
+        · exact Filter.EventuallyEq.filter_mono h₃g nhdsWithin_le_nhds
+    rw [this] at h₂f
+    apply AnalyticAt.smul
+    nth_rw 1 [← Int.toNat_of_nonneg (WithTop.coe_nonneg.mp h₂f)]
+    apply AnalyticAt.pow
+    apply AnalyticAt.sub
+    apply analyticAt_id -- Warning: want apply AnalyticAt.id
+    apply analyticAt_const -- Warning: want AnalyticAt.const
+    exact h₁g
+
+
+/- Analytic functions are strongly meromorphic -/
+theorem AnalyticAt.stronglyMeromorphicAt
+  {f : ℂ → ℂ}
+  {z₀ : ℂ}
+  (h₁f : AnalyticAt ℂ f z₀) :
+  StronglyMeromorphicAt f z₀ := by
+  by_cases h₂f : h₁f.order = ⊤
+  · rw [AnalyticAt.order_eq_top_iff] at h₂f
+    tauto
+  · have : h₁f.order ≠ ⊤ := h₂f
+    rw [← ENat.coe_toNat_eq_self] at this
+    rw [eq_comm, AnalyticAt.order_eq_nat_iff] at this
+    right
+    use h₁f.order.toNat
+    obtain ⟨g, h₁g, h₂g, h₃g⟩ := this
+    use g
+    tauto
+
+
+/- Strong meromorphic depends only on germ -/
+theorem stronglyMeromorphicAt_congr
+  {f g : ℂ → ℂ}
+  {z₀ : ℂ}
+  (hfg : f =ᶠ[𝓝 z₀] g) :
+  StronglyMeromorphicAt f z₀ ↔ StronglyMeromorphicAt g z₀ := by
+  unfold StronglyMeromorphicAt
+  constructor
+  · intro h
+    rcases h with h|h
+    · left
+      exact Filter.EventuallyEq.rw h (fun x => Eq (g x)) (id (Filter.EventuallyEq.symm hfg))
+    · obtain ⟨n, h, h₁h, h₂h, h₃h⟩ := h
+      right
+      use n
+      use h
+      constructor
+      · assumption
+      · constructor
+        · assumption
+        · apply Filter.EventuallyEq.trans hfg.symm
+          assumption
+  · intro h
+    rcases h with h|h
+    · left
+      exact Filter.EventuallyEq.rw h (fun x => Eq (f x)) hfg
+    · obtain ⟨n, h, h₁h, h₂h, h₃h⟩ := h
+      right
+      use n
+      use h
+      constructor
+      · assumption
+      · constructor
+        · assumption
+        · 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
+  {f : ℂ → ℂ}
+  {z₀ : ℂ}
+  (hf : MeromorphicAt f z₀) :
+  ℂ → ℂ := by
+  intro z
+  by_cases z = z₀
+  · by_cases h₁f : hf.order = (0 : ℤ)
+    · rw [hf.order_eq_int_iff] at h₁f
+      exact (Classical.choose h₁f) z₀
+    · exact 0
+  · exact f z
+
+
+lemma m₁
+  {f : ℂ → ℂ}
+  {z₀ : ℂ}
+  (hf : MeromorphicAt f z₀) :
+  ∀ z ≠ z₀, f z = hf.makeStronglyMeromorphicAt z := by
+  intro z hz
+  unfold MeromorphicAt.makeStronglyMeromorphicAt
+  simp [hz]
+
+
+lemma m₂
+  {f : ℂ → ℂ}
+  {z₀ : ℂ}
+  (hf : MeromorphicAt f z₀) :
+  f =ᶠ[𝓝[≠] z₀] hf.makeStronglyMeromorphicAt := by
+  apply eventually_nhdsWithin_of_forall
+  exact fun x a => m₁ hf x a
+
+
+theorem StronglyMeromorphicAt_of_makeStronglyMeromorphic
+  {f : ℂ → ℂ}
+  {z₀ : ℂ}
+  (hf : MeromorphicAt f z₀) :
+  StronglyMeromorphicAt hf.makeStronglyMeromorphicAt z₀ := by
+
+  by_cases h₂f : hf.order = ⊤
+  · have : hf.makeStronglyMeromorphicAt =ᶠ[𝓝 z₀] 0 := by
+      apply Mnhds
+      · apply Filter.EventuallyEq.trans (Filter.EventuallyEq.symm (m₂ hf))
+        exact (MeromorphicAt.order_eq_top_iff hf).1 h₂f
+      · unfold MeromorphicAt.makeStronglyMeromorphicAt
+        simp [h₂f]
+
+    apply AnalyticAt.stronglyMeromorphicAt
+    rw [analyticAt_congr this]
+    apply analyticAt_const
+  · let n := hf.order.untop h₂f
+    have : hf.order = n := by
+      exact Eq.symm (WithTop.coe_untop hf.order h₂f)
+    rw [hf.order_eq_int_iff] at this
+    obtain ⟨g, h₁g, h₂g, h₃g⟩ := this
+    right
+    use n
+    use g
+    constructor
+    · assumption
+    · constructor
+      · assumption
+      · apply Mnhds
+        · apply Filter.EventuallyEq.trans (Filter.EventuallyEq.symm (m₂ hf))
+          exact h₃g
+        · unfold MeromorphicAt.makeStronglyMeromorphicAt
+          simp
+          by_cases h₃f : hf.order = (0 : ℤ)
+          · let h₄f := (hf.order_eq_int_iff 0).1 h₃f
+            simp [h₃f]
+            obtain ⟨h₁G, h₂G, h₃G⟩  := Classical.choose_spec h₄f
+            simp at h₃G
+            have hn : n = 0 := Eq.symm ((fun {α} {a} {b} h => (WithTop.eq_untop_iff h).mpr) h₂f (id (Eq.symm h₃f)))
+            rw [hn]
+            rw [hn] at h₃g; simp at h₃g
+            simp
+            have : g =ᶠ[𝓝 z₀] (Classical.choose h₄f) := by
+              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
+            simp [this]
+            left
+            apply zero_zpow n
+            dsimp [n]
+            rwa [WithTop.untop_eq_iff h₂f]
+
+
+theorem StronglyMeromorphicAt.makeStronglyMeromorphic_id
+  {f : ℂ → ℂ}
+  {z₀ : ℂ}
+  (hf : StronglyMeromorphicAt f z₀) :
+  f = hf.meromorphicAt.makeStronglyMeromorphicAt := by
+
+  funext z
+  by_cases hz : z = z₀
+  · rw [hz]
+    unfold MeromorphicAt.makeStronglyMeromorphicAt
+    simp
+    have h₀f := hf
+    rcases hf with h₁f|h₁f
+    · have A : f =ᶠ[𝓝[≠] z₀] 0 := by
+        apply Filter.EventuallyEq.filter_mono h₁f
+        exact nhdsWithin_le_nhds
+      let B := (MeromorphicAt.order_eq_top_iff h₀f.meromorphicAt).2 A
+      simp [B]
+      exact Filter.EventuallyEq.eq_of_nhds h₁f
+    · obtain ⟨n, g, h₁g, h₂g, h₃g⟩ := h₁f
+      rw [Filter.EventuallyEq.eq_of_nhds h₃g]
+      have : h₀f.meromorphicAt.order = n := by
+        rw [MeromorphicAt.order_eq_int_iff (StronglyMeromorphicAt.meromorphicAt h₀f) n]
+        use g
+        constructor
+        · assumption
+        · constructor
+          · assumption
+          · exact eventually_nhdsWithin_of_eventually_nhds h₃g
+      by_cases h₃f : h₀f.meromorphicAt.order = 0
+      · simp [h₃f]
+        have hn : n = (0 : ℤ) := by
+          rw [h₃f] at this
+          exact WithTop.coe_eq_zero.mp (id (Eq.symm this))
+        simp_rw [hn]
+        simp
+        let t₀ : h₀f.meromorphicAt.order = (0 : ℤ) := by
+          exact h₃f
+        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 h₁g.localIdentity h₀
+          rw [hn] at h₃g
+          simp at h₃g
+          simp at h₂
+          have h₄g : f =ᶠ[𝓝[≠] z₀] g := by
+            apply Filter.EventuallyEq.filter_mono h₃g
+            exact nhdsWithin_le_nhds
+          exact Filter.EventuallyEq.trans (Filter.EventuallyEq.symm h₄g) h₂
+        exact Filter.EventuallyEq.eq_of_nhds this
+      · simp [h₃f]
+        left
+        apply zero_zpow n
+        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

@@ -0,0 +1,163 @@
+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 : ℂ → ℂ)
+  (U : Set ℂ) :=
+  ∀ z ∈ U, StronglyMeromorphicAt f z
+
+
+/- Strongly MeromorphicAt is Meromorphic -/
+theorem StronglyMeromorphicOn.meromorphicOn
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (hf : StronglyMeromorphicOn f U) :
+  MeromorphicOn f U := by
+  intro z hz
+  exact StronglyMeromorphicAt.meromorphicAt (hf z hz)
+
+
+/- Strongly MeromorphicOn of non-negative order is analytic -/
+theorem StronglyMeromorphicOn.analytic
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (h₁f : StronglyMeromorphicOn f U)
+  (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
+  exact h₁f z hz
+
+
+/- Analytic functions are strongly meromorphic -/
+theorem AnalyticOn.stronglyMeromorphicOn
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (h₁f : AnalyticOnNhd ℂ f U) :
+  StronglyMeromorphicOn f U := by
+  intro z hz
+  apply AnalyticAt.stronglyMeromorphicAt
+  exact h₁f z hz
+
+
+theorem stronglyMeromorphicOn_of_mul_analytic'
+  {f g : ℂ → ℂ}
+  {U : Set ℂ}
+  (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⟩
+
+
+/- Make strongly MeromorphicOn -/
+noncomputable def MeromorphicOn.makeStronglyMeromorphicOn
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  (hf : MeromorphicOn f U) :
+  ℂ → ℂ := by
+  intro z
+  by_cases hz : z ∈ U
+  · exact (hf z hz).makeStronglyMeromorphicAt z
+  · exact f z
+
+
+theorem makeStronglyMeromorphicOn_changeDiscrete
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  {z₀ : ℂ}
+  (hf : MeromorphicOn f U)
+  (hz₀ : z₀ ∈ U) :
+  hf.makeStronglyMeromorphicOn =ᶠ[𝓝[≠] z₀] f := by
+  apply Filter.eventually_iff_exists_mem.2
+  let A := (hf z₀ hz₀).eventually_analyticAt
+  obtain ⟨V, h₁V, h₂V⟩  := Filter.eventually_iff_exists_mem.1 A
+  use V
+  constructor
+  · assumption
+  · intro v hv
+    unfold MeromorphicOn.makeStronglyMeromorphicOn
+    by_cases h₂v : v ∈ U
+    · simp [h₂v]
+      rw [← StronglyMeromorphicAt.makeStronglyMeromorphic_id]
+      exact AnalyticAt.stronglyMeromorphicAt (h₂V v hv)
+    · simp [h₂v]
+
+
+theorem makeStronglyMeromorphicOn_changeDiscrete'
+  {f : ℂ → ℂ}
+  {U : Set ℂ}
+  {z₀ : ℂ}
+  (hf : MeromorphicOn f U)
+  (hz₀ : z₀ ∈ U) :
+  hf.makeStronglyMeromorphicOn =ᶠ[𝓝 z₀] (hf z₀ hz₀).makeStronglyMeromorphicAt := by
+  apply Mnhds
+  · apply Filter.EventuallyEq.trans (makeStronglyMeromorphicOn_changeDiscrete hf hz₀)
+    exact m₂ (hf z₀ hz₀)
+  · rw [MeromorphicOn.makeStronglyMeromorphicOn]
+    simp [hz₀]
+
+
+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
+  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]

Nevanlinna/test.lean

@@ -1,130 +0,0 @@
-import Mathlib.Analysis.Complex.CauchyIntegral
---import Mathlib.Analysis.Complex.Module
-
-
-open ComplexConjugate
-
-#check DiffContOnCl.circleIntegral_sub_inv_smul
-
-open Real
-
-theorem CauchyIntegralFormula :
-  ∀
-  {R : ℝ} -- Radius of the ball
-  {w : ℂ} -- Point in the interior of the ball
-  {f : ℂ → ℂ}, -- Holomorphic function
-  DiffContOnCl ℂ f (Metric.ball 0 R)
-  → w ∈ Metric.ball 0 R
-  → (∮ (z : ℂ) in C(0, R), (z - w)⁻¹ • f z) = (2 * π * Complex.I) • f w := by
-
-  exact DiffContOnCl.circleIntegral_sub_inv_smul
-
-#check CauchyIntegralFormula
-#check HasDerivAt.continuousAt
-#check Real.log
-#check ComplexConjugate.conj
-#check Complex.exp
-
-theorem SimpleCauchyFormula :
-  ∀
-  {R : ℝ} -- Radius of the ball
-  {w : ℂ} -- Point in the interior of the ball
-  {f : ℂ → ℂ}, -- Holomorphic function
-  Differentiable ℂ f
-  → w ∈ Metric.ball 0 R
-  → (∮ (z : ℂ) in C(0, R), (z - w)⁻¹ • f z) = (2 * Real.pi * Complex.I) • f w := by
-
-  intro R w f fHyp
-
-  apply DiffContOnCl.circleIntegral_sub_inv_smul
-
-  constructor
-  · exact Differentiable.differentiableOn fHyp
-  · suffices Continuous f from by
-      exact Continuous.continuousOn this
-    rw [continuous_iff_continuousAt]
-    intro x
-    exact DifferentiableAt.continuousAt (fHyp x)
-
-
-theorem JensenFormula₂ :
-  ∀
-  {R : ℝ} -- Radius of the ball
-  {f : ℂ → ℂ}, -- Holomorphic function
-  Differentiable ℂ f
-  → (∀ z ∈ Metric.ball 0 R, f z ≠ 0)
-  → (∫ (θ : ℝ) in Set.Icc 0 (2 * π), Complex.log ‖f (circleMap 0 R θ)‖ ) = 2 * π * Complex.log ‖f 0‖ := by
-
-  intro r f fHyp₁ fHyp₂
-
-  /- We treat the trivial case r = 0 separately. -/
-  by_cases rHyp : r = 0
-  rw [rHyp]
-  simp
-  left
-  unfold ENNReal.ofReal
-  simp
-  rw [max_eq_left (mul_nonneg zero_le_two pi_nonneg)]
-  simp
-  /- From hereon, we assume that r ≠ 0. -/
-
-  /- Replace the integral over 0 … 2π by a circle integral -/
-  suffices (∮ (z : ℂ) in C(0, r), -(Complex.I * z⁻¹ * Complex.log ↑(Complex.abs (f z)))) = 2 * ↑π * Complex.log ↑‖f 0‖ from by
-    have : ∫ (θ : ℝ) in Set.Icc 0 (2 * π), Complex.log ↑‖f (circleMap 0 r θ)‖ = (∮ (z : ℂ) in C(0, r), -(Complex.I * z⁻¹ * Complex.log ↑(Complex.abs (f z)))) := by
-      have : (fun θ ↦ Complex.log ‖f (circleMap 0 r θ)‖) = (fun θ ↦ ((deriv (circleMap 0 r) θ)) • ((deriv (circleMap 0 r) θ)⁻¹ • Complex.log ↑‖f (circleMap 0 r θ)‖)) := by
-        funext θ
-        rw [← smul_assoc, smul_eq_mul, smul_eq_mul, mul_inv_cancel, one_mul]
-        simp
-        exact rHyp
-      rw [this]
-      simp
-      let tmp := circleIntegral_def_Icc (fun z ↦ -(Complex.I * z⁻¹ * (Complex.log ↑‖f z‖))) 0 r
-      simp at tmp
-      rw [← tmp]
-    rw [this]
-
-  
-
-  have : ∀ z : ℂ, log (Complex.abs z) = 1/2 * Complex.log z + 1/2 * Complex.log (conj z) := by
-    intro z
-
-    by_cases argHyp : Complex.arg z = π 
-    
-    · rw [Complex.log, argHyp, Complex.log]
-      let ZZ := Complex.arg_conj z
-      rw [argHyp] at ZZ
-      
-      simp at ZZ
-
-      have : conj z = z := by
-        apply?
-        sorry
-
-    let ZZ := Complex.log_conj z
-
-    nth_rewrite 1 [Complex.log]
-    
-    simp
-
-    let φ := Complex.arg z
-    let r := Complex.abs z
-    have : z = r * Complex.exp (φ * Complex.I) := by
-      exact (Complex.abs_mul_exp_arg_mul_I z).symm
-
-    have : Complex.log z = Complex.log r + r*Complex.I := by
-      apply?
-      sorry
-    simp at XX
-
-
-    sorry
-
-
-
-
-
-
-
-
-
-  sorry

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,68 +1,95 @@
-{"version": 7,
+{"version": "1.1.0",
  "packagesDir": ".lake/packages",
  "packages":
- [{"url": "https://github.com/leanprover/std4",
+ [{"url": "https://github.com/leanprover-community/mathlib4.git",
    "type": "git",
    "subDir": null,
-   "rev": "e840c18f7334c751efbd4cfe531476e10c943cdb",
-   "name": "std",
+   "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": "8e5cb8d424df462f84997dd68af6f40e347c3e35",
+   "name": "plausible",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "v4.15.0-rc1",
+   "inherited": true,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/leanprover-community/LeanSearchClient",
+   "type": "git",
+   "subDir": null,
+   "scope": "leanprover-community",
+   "rev": "003ff459cdd85de551f4dcf95cdfeefe10f20531",
+   "name": "LeanSearchClient",
    "manifestFile": "lake-manifest.json",
    "inputRev": "main",
    "inherited": true,
-   "configFile": "lakefile.lean"},
-  {"url": "https://github.com/leanprover-community/quote4",
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/leanprover-community/import-graph",
    "type": "git",
    "subDir": null,
-   "rev": "64365c656d5e1bffa127d2a1795f471529ee0178",
-   "name": "Qq",
+   "scope": "leanprover-community",
+   "rev": "ed3b856bd8893ade75cafe13e8544d4c2660f377",
+   "name": "importGraph",
    "manifestFile": "lake-manifest.json",
-   "inputRev": "master",
+   "inputRev": "v4.15.0-rc1",
+   "inherited": true,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/leanprover-community/ProofWidgets4",
+   "type": "git",
+   "subDir": null,
+   "scope": "leanprover-community",
+   "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,
-   "rev": "5fefb40a7c9038a7150e7edd92e43b1b94c49e79",
+   "scope": "leanprover-community",
+   "rev": "a4a08d92be3de00def5298059bf707c72dfd3c66",
    "name": "aesop",
    "manifestFile": "lake-manifest.json",
    "inputRev": "master",
    "inherited": true,
-   "configFile": "lakefile.lean"},
-  {"url": "https://github.com/leanprover-community/ProofWidgets4",
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/leanprover-community/quote4",
    "type": "git",
    "subDir": null,
-   "rev": "fb65c476595a453a9b8ffc4a1cea2db3a89b9cd8",
-   "name": "proofwidgets",
+   "scope": "leanprover-community",
+   "rev": "ad942fdf0b15c38bface6acbb01d63855a2519ac",
+   "name": "Qq",
    "manifestFile": "lake-manifest.json",
-   "inputRev": "v0.0.30",
+   "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/lean4-cli",
    "type": "git",
    "subDir": null,
-   "rev": "be8fa79a28b8b6897dce0713ef50e89c4a0f6ef5",
+   "scope": "leanprover",
+   "rev": "0c8ea32a15a4f74143e4e1e107ba2c412adb90fd",
    "name": "Cli",
    "manifestFile": "lake-manifest.json",
    "inputRev": "main",
    "inherited": true,
-   "configFile": "lakefile.lean"},
-  {"url": "https://github.com/leanprover-community/import-graph.git",
-   "type": "git",
-   "subDir": null,
-   "rev": "61a79185b6582573d23bf7e17f2137cd49e7e662",
-   "name": "importGraph",
-   "manifestFile": "lake-manifest.json",
-   "inputRev": "main",
-   "inherited": true,
-   "configFile": "lakefile.lean"},
-  {"url": "https://github.com/leanprover-community/mathlib4.git",
-   "type": "git",
-   "subDir": null,
-   "rev": "e408da18380ef42acf7b8337c6b0536bfac09105",
-   "name": "mathlib",
-   "manifestFile": "lake-manifest.json",
-   "inputRev": null,
-   "inherited": false,
-   "configFile": "lakefile.lean"}],
+   "configFile": "lakefile.toml"}],
  "name": "nevanlinna",
  "lakeDir": ".lake"}

lean-toolchain

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