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 ℝ

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

@@ -1,9 +0,0 @@
-import Mathlib.Analysis.Calculus.ContDiff.Basic
-import Mathlib.Analysis.InnerProductSpace.PiL2
-
-/-
-
-Here we would like to define differential operators, following EGA 4-1, §20.
-This is work to be done in the future.
-
--/

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

@@ -1,9 +1,9 @@
 import Nevanlinna.laplace
 
 variable {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F]
-variable {F₁ : Type*} [NormedAddCommGroup F₁] [NormedSpace ℂ F₁] [CompleteSpace F₁]
+variable {F₁ : Type*} [NormedAddCommGroup F₁] [NormedSpace ℂ F₁]
 variable {G : Type*} [NormedAddCommGroup G] [NormedSpace ℝ G]
-variable {G₁ : Type*} [NormedAddCommGroup G₁] [NormedSpace ℂ G₁] [CompleteSpace G₁]
+variable {G₁ : Type*} [NormedAddCommGroup G₁] [NormedSpace ℂ G₁]
 
 
 def Harmonic (f : ℂ → F) : Prop :=
@@ -22,7 +22,7 @@ theorem HarmonicAt_iff
   HarmonicAt f x ↔ ∃ s : Set ℂ, IsOpen s ∧ x ∈ s ∧ (ContDiffOn ℝ 2 f s) ∧ (∀ z ∈ s, Δ f z = 0) := by
   constructor
   · intro hf
-    obtain ⟨s₁, h₁s₁, h₂s₁, h₃s₁⟩ := hf.1.contDiffOn' le_rfl
+    obtain ⟨s₁, h₁s₁, h₂s₁, h₃s₁⟩ := hf.1.contDiffOn' le_rfl (by trivial)
     simp at h₃s₁
     obtain ⟨t₂, h₁t₂, h₂t₂⟩ := (Filter.eventuallyEq_iff_exists_mem.1 hf.2)
     obtain ⟨s₂, h₁s₂, h₂s₂, h₃s₂⟩ := mem_nhds_iff.1 h₁t₂
@@ -261,7 +261,7 @@ theorem harmonicAt_comp_CLM_is_harmonicAt
     apply ContDiffAt.continuousLinearMap_comp
     exact h.1
   · -- Δ (⇑l ∘ f) =ᶠ[nhds z] 0
-    obtain ⟨r, h₁r, h₂r⟩ := h.1.contDiffOn le_rfl
+    obtain ⟨r, h₁r, h₂r⟩ := h.1.contDiffOn le_rfl (by trivial)
     obtain ⟨s, h₁s, h₂s, h₃s⟩ := mem_nhds_iff.1 h₁r
     obtain ⟨t, h₁t, h₂t⟩ := Filter.eventuallyEq_iff_exists_mem.1 h.2
     obtain ⟨u, h₁u, h₂u, h₃u⟩ := mem_nhds_iff.1 h₁t

Nevanlinna/harmonicAt_meanValue.lean

@@ -63,7 +63,7 @@ theorem harmonic_meanValue
     nth_rw 1 [mul_comm]
     rw [← mul_assoc]
     simp
-    apply inv_mul_cancel
+    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

Nevanlinna/holomorphicAt.lean

@@ -1,4 +1,4 @@
-import Mathlib.Analysis.Complex.TaylorSeries
+import Mathlib.Analysis.Complex.CauchyIntegral
 import Nevanlinna.cauchyRiemann
 
 variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
@@ -110,6 +110,38 @@ theorem HolomorphicAt_neg
     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}

Nevanlinna/holomorphic_JensenFormula.lean

@@ -1,157 +0,0 @@
-import Nevanlinna.harmonicAt_examples
-import Nevanlinna.harmonicAt_meanValue
-import Nevanlinna.specialFunctions_CircleIntegral_affine
-
-
-theorem jensen_case_R_eq_one
-  (f : ℂ → ℂ)
-  (h₁f : Differentiable ℂ f)
-  (h₂f : f 0 ≠ 0)
-  (S : Finset ℕ)
-  (a : S → ℂ)
-  (ha : ∀ s, a s ∈ Metric.ball 0 1)
-  (F : ℂ → ℂ)
-  (h₁F : Differentiable ℂ F)
-  (h₂F : ∀ z, F z ≠ 0)
-  (h₃F : f = fun z ↦ (F z) * ∏ s : S, (z - a s))
-  :
-  Real.log ‖f 0‖ = -∑ s, Real.log (‖a s‖⁻¹) + (2 * Real.pi)⁻¹ * ∫ (x : ℝ) in (0)..2 * Real.pi, Real.log ‖f (circleMap 0 1 x)‖ := by
-
-  let logAbsF := fun w ↦ Real.log ‖F w‖
-
-  have t₀ : ∀ z ∈ Metric.ball 0 2, HarmonicAt logAbsF z := by
-    intro z _
-    apply logabs_of_holomorphicAt_is_harmonic
-    apply h₁F.holomorphicAt
-    exact h₂F z
-
-  have t₁ : (∫ (x : ℝ) in (0)..2 * Real.pi, logAbsF (circleMap 0 1 x)) = 2 * Real.pi * logAbsF 0 := by
-    have hR : (0 : ℝ) < (1 : ℝ) := by apply Real.zero_lt_one
-    have hρ : (1 : ℝ) < (2 : ℝ) := by linarith
-    apply harmonic_meanValue 2 1 hR hρ t₀
-
-
-  have t₂ : ∀ s, f (a s) = 0 := by
-    intro s
-    rw [h₃F]
-    simp
-    right
-    apply Finset.prod_eq_zero_iff.2
-    use s
-    simp
-
-  let logAbsf := fun w ↦ Real.log ‖f w‖
-  have s₀ : ∀ z, f z ≠ 0 → logAbsf z = logAbsF z + ∑ s, Real.log ‖z - a s‖ := by
-    intro z hz
-    dsimp [logAbsf]
-    rw [h₃F]
-    simp_rw [Complex.abs.map_mul]
-    rw [Complex.abs_prod]
-    rw [Real.log_mul]
-    rw [Real.log_prod]
-    rfl
-    intro s hs
-    simp
-    by_contra ha'
-    rw [ha'] at hz
-    exact hz (t₂ s)
-    -- Complex.abs (F z) ≠ 0
-    simp
-    exact h₂F z
-    -- ∏ I : { x // x ∈ S }, Complex.abs (z - a I) ≠ 0
-    by_contra h'
-    obtain ⟨s, h's, h''⟩ := Finset.prod_eq_zero_iff.1 h'
-    simp at h''
-    rw [h''] at hz
-    let A := t₂ s
-    exact hz A
-
-  have s₁ : ∀ z, f z ≠ 0 → logAbsF z = logAbsf z - ∑ s, Real.log ‖z - a s‖ := by
-    intro z hz
-    rw [s₀ z hz]
-    simp
-
-  rw [s₁ 0 h₂f] at t₁
-
-  have h₀ {x : ℝ} : f (circleMap 0 1 x) ≠ 0 := by
-    rw [h₃F]
-    simp
-    constructor
-    · exact h₂F (circleMap 0 1 x)
-    · by_contra h'
-      obtain ⟨s, _, h₂s⟩  := Finset.prod_eq_zero_iff.1 h'
-      have : circleMap 0 1 x = a s := by
-        rw [← sub_zero (circleMap 0 1 x)]
-        nth_rw 2 [← h₂s]
-        simp
-      let A := ha s
-      rw [← this] at A
-      simp at A
-
-  simp_rw [s₁ (circleMap 0 1 _) h₀] at t₁
-  rw [intervalIntegral.integral_sub] at t₁
-  rw [intervalIntegral.integral_finset_sum] at t₁
-
-  simp_rw [int₀ (ha _)] at t₁
-  simp at t₁
-  rw [t₁]
-  simp
-  have {w : ℝ} : Real.pi⁻¹ * 2⁻¹ * (2 * Real.pi * w) = w := by
-    ring_nf
-    simp [mul_inv_cancel Real.pi_ne_zero]
-  rw [this]
-  simp
-  rfl
-  -- ∀ i ∈ Finset.univ, IntervalIntegrable (fun x => Real.log ‖circleMap 0 1 x - a i‖) MeasureTheory.volume 0 (2 * Real.pi)
-  intro i _
-  apply Continuous.intervalIntegrable
-  apply continuous_iff_continuousAt.2
-  intro x
-  have : (fun x => Real.log ‖circleMap 0 1 x - a i‖) = Real.log ∘ Complex.abs ∘ (fun x ↦ circleMap 0 1 x - a i) :=
-    rfl
-  rw [this]
-  apply ContinuousAt.comp
-  apply Real.continuousAt_log
-  simp
-  by_contra ha'
-  let A := ha i
-  rw [← ha'] at A
-  simp at A
-  apply ContinuousAt.comp
-  apply Complex.continuous_abs.continuousAt
-  fun_prop
-  -- IntervalIntegrable (fun x => logAbsf (circleMap 0 1 x)) MeasureTheory.volume 0 (2 * Real.pi)
-  apply Continuous.intervalIntegrable
-  apply continuous_iff_continuousAt.2
-  intro x
-  have : (fun x => logAbsf (circleMap 0 1 x)) = Real.log ∘ Complex.abs ∘ f ∘ (fun x ↦ circleMap 0 1 x) :=
-    rfl
-  rw [this]
-  apply ContinuousAt.comp
-  simp
-  exact h₀
-  apply ContinuousAt.comp
-  apply Complex.continuous_abs.continuousAt
-  apply ContinuousAt.comp
-  apply h₁f.continuous.continuousAt
-  let A := continuous_circleMap 0 1
-  apply A.continuousAt
-  -- IntervalIntegrable (fun x => ∑ s : { x // x ∈ S }, Real.log ‖circleMap 0 1 x - a s‖) MeasureTheory.volume 0 (2 * Real.pi)
-  apply Continuous.intervalIntegrable
-  apply continuous_finset_sum
-  intro i _
-  apply continuous_iff_continuousAt.2
-  intro x
-  have : (fun x => Real.log ‖circleMap 0 1 x - a i‖) = Real.log ∘ Complex.abs ∘ (fun x ↦ circleMap 0 1 x - a i) :=
-    rfl
-  rw [this]
-  apply ContinuousAt.comp
-  apply Real.continuousAt_log
-  simp
-  by_contra ha'
-  let A := ha i
-  rw [← ha'] at A
-  simp at A
-  apply ContinuousAt.comp
-  apply Complex.continuous_abs.continuousAt
-  fun_prop

Nevanlinna/holomorphic_JensenFormula2.lean

@@ -1,41 +0,0 @@
-import Mathlib.Analysis.Complex.CauchyIntegral
-import Nevanlinna.harmonicAt_examples
-import Nevanlinna.harmonicAt_meanValue
-import Mathlib.Analysis.Analytic.IsolatedZeros
-
-
-lemma xx
-  {f : ℂ → ℂ}
-  {S : Set ℂ}
-  (h₁S : IsPreconnected S)
-  (h₂S : IsCompact S)
-  (hf : ∀ s ∈ S, AnalyticAt ℂ f s) :
-  ∃ o : ℂ → ℕ, ∃ F : ℂ → ℂ, ∀ z ∈ S, (AnalyticAt ℂ F z) ∧ (F z ≠ 0) ∧ (f z = F z * ∏ᶠ s ∈ S, (z - s) ^ (o s)) := by
-
-  let o : ℂ → ℕ := by
-    intro z
-    if hz : z ∈ S then
-      let A := hf z hz
-      let B := A.order
-
-      exact (A.order : ⊤)
-    else
-      exact 0
-
-  sorry
-
-
-theorem jensen_case_R_eq_one'
-  (f : ℂ → ℂ)
-  (h₁f : Differentiable ℂ f)
-  (h₂f : f 0 ≠ 0)
-  (S : Finset ℕ)
-  (a : S → ℂ)
-  (ha : ∀ s, a s ∈ Metric.ball 0 1)
-  (F : ℂ → ℂ)
-  (h₁F : Differentiable ℂ F)
-  (h₂F : ∀ z, F z ≠ 0)
-  (h₃F : f = fun z ↦ (F z) * ∏ s : S, (z - a s))
-  :
-  Real.log ‖f 0‖ = -∑ s, Real.log (‖a s‖⁻¹) + (2 * Real.pi)⁻¹ * ∫ (x : ℝ) in (0)..2 * Real.pi, Real.log ‖f (circleMap 0 1 x)‖ := by
-  sorry

Nevanlinna/holomorphic_examples.lean

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

Nevanlinna/holomorphic_primitive.lean

@@ -666,10 +666,10 @@ theorem primitive_additivity'
       dsimp [ε']; simp
       have : |ε| = ε := by apply abs_of_pos h₁ε
       rw [this]
-      apply (inv_mul_lt_iff zero_lt_two).mpr
+      apply (inv_mul_lt_iff₀ zero_lt_two).mpr
       linarith
     have h₁ε' : 0 < ε' := by
-      apply Real.mul_pos _ h₁ε
+      apply mul_pos _ h₁ε
       apply inv_pos.mpr
       exact zero_lt_two
 

Nevanlinna/holomorphic_zero.lean

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

Nevanlinna/intervalIntegrability.lean

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

Nevanlinna/junk/holomorphic_primitive.lean

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

Nevanlinna/laplace.lean

@@ -85,11 +85,11 @@ theorem laplace_add_ContDiffOn
   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 (Submonoid.oneLE.proof_2 ℕ∞)
+    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 (Submonoid.oneLE.proof_2 ℕ∞)
+    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
@@ -105,11 +105,11 @@ theorem laplace_add_ContDiffOn
   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 (Submonoid.oneLE.proof_2 ℕ∞)
+    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 (Submonoid.oneLE.proof_2 ℕ∞)
+    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.
@@ -219,6 +219,7 @@ theorem laplace_compCLMAt
     obtain ⟨u, hu₁, hu₂⟩ : ∃ u ∈ nhds x, ContDiffOn ℝ 2 f u := by
       apply ContDiffAt.contDiffOn h
       rfl
+      simp
     obtain ⟨v, hv₁, hv₂, hv₃⟩ := mem_nhds_iff.1 hu₁
     use v
     constructor

Nevanlinna/laplace2.lean

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

Nevanlinna/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

@@ -1,21 +1,25 @@
 import Mathlib.Analysis.Analytic.Constructions
 import Mathlib.Analysis.Analytic.IsolatedZeros
 import Mathlib.Analysis.Complex.Basic
+import Nevanlinna.analyticAt
 
 
-theorem AnalyticOn.order_eq_nat_iff
+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₀ : ℂ}
-  (hf : AnalyticOn ℂ f U)
-  (hz₀ : z₀ ∈ U)
+  {z₀ : U}
+  (hf : AnalyticOnNhd ℂ f U)
   (n : ℕ) :
-  (hf z₀ hz₀).order = ↑n ↔ ∃ (g : ℂ → ℂ), AnalyticOn ℂ g U ∧ g z₀ ≠ 0 ∧ ∀ z, f z = (z - z₀) ^ n • g z := by
+  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₀ hz₀) n).1 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
@@ -44,7 +48,7 @@ theorem AnalyticOn.order_eq_nat_iff
   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₀}ᶜ
+    use {z₀.1}ᶜ
     constructor
     · intro y hy
       simp at hy
@@ -79,7 +83,7 @@ theorem AnalyticOn.order_eq_nat_iff
         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]
+        rw [div_eq_mul_inv, mul_comm, mul_assoc, inv_mul_cancel₀]
         simp; norm_num
         rw [sub_eq_zero]
         tauto
@@ -87,70 +91,31 @@ theorem AnalyticOn.order_eq_nat_iff
   -- 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₀ hz₀, ⟨h₂g, Filter.eventually_of_forall h₃g⟩⟩
+  exact ⟨h₁g z₀ z₀.2, ⟨h₂g, Filter.Eventually.of_forall h₃g⟩⟩
 
 
-theorem AnalyticAt.order_mul
-  {f₁ f₂ : ℂ → ℂ}
-  {z₀ : ℂ}
-  (hf₁ : AnalyticAt ℂ f₁ z₀)
-  (hf₂ : AnalyticAt ℂ f₂ z₀) :
-  (AnalyticAt.mul hf₁ 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 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 AnalyticOn.eliminateZeros
+theorem AnalyticOnNhd.eliminateZeros
   {f : ℂ → ℂ}
   {U : Set ℂ}
   {A : Finset U}
-  (hf : AnalyticOn ℂ f U)
-  (n : ℂ → ℕ) :
-  (∀ a ∈ A, (hf a.1 a.2).order = n a) → ∃ (g : ℂ → ℂ), AnalyticOn ℂ g U ∧ (∀ a ∈ A, g a ≠ 0) ∧ ∀ z, f z = (∏ a ∈ A, (z - a) ^ (n a)) • g z := by
+  (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 : ℂ → ℂ), AnalyticOn ℂ g U ∧ (∀ a ∈ A, g a ≠ 0) ∧ ∀ z, f z = (∏ a ∈ A, (z - a) ^ (n a)) • g z)
+  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
@@ -167,7 +132,7 @@ theorem AnalyticOn.eliminateZeros
 
     rw [← hBinsert b₀ (Finset.mem_insert_self b₀ B)]
 
-    let φ := fun z ↦ (∏ a ∈ B, (z - a.1) ^ n a.1)
+    let φ := fun z ↦ (∏ a ∈ B, (z - a.1) ^ n a)
 
     have : f = fun z ↦ φ z * g₀ z := by
       funext z
@@ -181,7 +146,7 @@ theorem AnalyticOn.eliminateZeros
       intro b _
       apply AnalyticAt.pow
       apply AnalyticAt.sub
-      apply analyticAt_id ℂ
+      apply analyticAt_id
       exact analyticAt_const
 
     have h₂φ : h₁φ.order = (0 : ℕ) := by
@@ -208,8 +173,7 @@ theorem AnalyticOn.eliminateZeros
     rw [h₂φ]
     simp
 
-
-  obtain ⟨g₁, h₁g₁, h₂g₁, h₃g₁⟩ := (AnalyticOn.order_eq_nat_iff h₁g₀ b₀.2 (n b₀)).1 this
+  obtain ⟨g₁, h₁g₁, h₂g₁, h₃g₁⟩ := (AnalyticOnNhd.order_eq_nat_iff h₁g₀ (n b₀)).1 this
 
   use g₁
   constructor
@@ -239,7 +203,7 @@ theorem XX
   {f : ℂ → ℂ}
   {U : Set ℂ}
   (hU : IsPreconnected U)
-  (h₁f : AnalyticOn ℂ f 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
 
@@ -257,16 +221,16 @@ theorem discreteZeros
   {f : ℂ → ℂ}
   {U : Set ℂ}
   (hU : IsPreconnected U)
-  (h₁f : AnalyticOn ℂ f U)
+  (h₁f : AnalyticOnNhd ℂ f U)
   (h₂f : ∃ u ∈ U, f u ≠ 0) :
-  DiscreteTopology ↑(U ∩ f⁻¹' {0}) := by
+  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.2.1
+  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
@@ -311,9 +275,9 @@ theorem discreteZeros
     _ < min ε₁ ε₂ := by assumption
     _ ≤ ε₁ := by exact min_le_left ε₁ ε₂
 
-
   have F := h₂ε₂ y.1 h₂y
-  rw [y.2.2] at F
+  have : f y = 0 := by exact y.2
+  rw [this] at F
   simp at F
 
   have : g y.1 ≠ 0 := by
@@ -329,68 +293,51 @@ theorem finiteZeros
   {U : Set ℂ}
   (h₁U : IsPreconnected U)
   (h₂U : IsCompact U)
-  (h₁f : AnalyticOn ℂ f U)
+  (h₁f : AnalyticOnNhd ℂ f U)
   (h₂f : ∃ u ∈ U, f u ≠ 0) :
-  Set.Finite ↑(U ∩ f⁻¹' {0}) := by
+  Set.Finite (U.restrict f⁻¹' {0}) := by
 
-  have hinter : IsCompact ↑(U ∩ f⁻¹' {0}) := by
-    apply IsCompact.of_isClosed_subset h₂U
-    apply h₁f.continuousOn.preimage_isClosed_of_isClosed
-    exact IsCompact.isClosed h₂U
+  have closedness : IsClosed (U.restrict f⁻¹' {0}) := by
+    apply IsClosed.preimage
+    apply continuousOn_iff_continuous_restrict.1
+    exact h₁f.continuousOn
     exact isClosed_singleton
-    exact Set.inter_subset_left
 
-  apply hinter.finite
-  apply DiscreteTopology.of_subset (s := ↑(U ∩ f⁻¹' {0}))
+  have : CompactSpace U := by
+    exact isCompact_iff_compactSpace.mp h₂U
+
+  apply (IsClosed.isCompact closedness).finite
   exact discreteZeros h₁U h₁f h₂f
-  rfl
 
 
-theorem AnalyticOnCompact.eliminateZeros
+theorem AnalyticOnNhdCompact.eliminateZeros
   {f : ℂ → ℂ}
   {U : Set ℂ}
   (h₁U : IsPreconnected U)
   (h₂U : IsCompact U)
-  (h₁f : AnalyticOn ℂ f U)
+  (h₁f : AnalyticOnNhd ℂ f U)
   (h₂f : ∃ u ∈ U, f u ≠ 0) :
-  ∃ (g : ℂ → ℂ) (A : Finset U), AnalyticOn ℂ g U ∧ (∀ z ∈ U, g z ≠ 0) ∧ ∀ z, f z = (∏ a ∈ A, (z - a) ^ (h₁f a a.2).order.toNat) • g z := by
+  ∃ (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 ι : U → ℂ := Subtype.val
+  let A := (finiteZeros h₁U h₂U h₁f h₂f).toFinset
 
-  let A₁ := ι⁻¹' (U ∩ f⁻¹' {0})
-
-  have : A₁.Finite := by
-    apply Set.Finite.preimage
-    exact Set.injOn_subtype_val
-    exact finiteZeros h₁U h₂U h₁f h₂f
-  let A := this.toFinset
-
-  let n : ℂ → ℕ := by
-    intro z
-    by_cases hz : z ∈ U
-    · exact (h₁f z hz).order.toNat
-    · exact 0
+  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]
-    simp
+    dsimp [n, AnalyticOnNhd.order]
     rw [eq_comm]
     apply XX h₁U
     exact h₂f
 
-  obtain ⟨g, h₁g, h₂g, h₃g⟩ := AnalyticOn.eliminateZeros (A := A) h₁f n hn
+
+  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]
-    congr
-    funext a
-    congr
-    dsimp [n]
-    simp [a.2]
 
   constructor
   · exact h₁g
@@ -400,15 +347,115 @@ theorem AnalyticOnCompact.eliminateZeros
       · exact h₂g ⟨z, h₁z⟩ h₂z
       · have : f z ≠ 0 := by
           by_contra C
-          have : ⟨z, h₁z⟩ ∈ ↑A₁ := by
-            dsimp [A₁, ι]
-            simp
-            exact C
           have : ⟨z, h₁z⟩ ∈ ↑A.toSet := by
             dsimp [A]
             simp
-            exact this
+            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

@@ -28,7 +28,7 @@ orthonormal basis `v` as `∑ i, (v i) ⊗ₜ[ℝ] (v i)`.
 
 -/
 
-
+open InnerProductSpace
 open TensorProduct
 
 
@@ -41,12 +41,11 @@ 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
+  (v : OrthonormalBasis ι ℝ E) :
+  InnerProductSpace.canonicalCovariantTensor E = ∑ i, (v i) ⊗ₜ[ℝ] (v i) := by
 
   let w := stdOrthonormalBasis ℝ E
   conv =>

Nevanlinna/leftovers/diffOp.lean

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

Nevanlinna/leftovers/holomorphic.lean

@@ -2,8 +2,8 @@ import Mathlib.Analysis.Complex.TaylorSeries
 import Nevanlinna.cauchyRiemann
 
 variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
-variable {F : Type*} [NormedAddCommGroup F] [NormedSpace ℂ F] [CompleteSpace F]
-variable {G : Type*} [NormedAddCommGroup G] [NormedSpace ℂ G] [CompleteSpace G]
+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
@@ -33,6 +33,21 @@ theorem HolomorphicAt_iff
     · 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} :
@@ -105,6 +120,7 @@ theorem HolomorphicAt_neg
 
 
 theorem HolomorphicAt_contDiffAt
+  [CompleteSpace F]
   {f : ℂ → F}
   {z : ℂ}
   (hf : HolomorphicAt f z) :

Nevanlinna/leftovers/holomorphic_zero.lean

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

Nevanlinna/logpos.lean

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

Nevanlinna/mathlibAddOn.lean

@@ -1,5 +1,7 @@
+import Mathlib.Analysis.Analytic.Meromorphic
 import Mathlib.Analysis.Calculus.ContDiff.Basic
 import Mathlib.Analysis.Calculus.FDeriv.Add
+import Nevanlinna.analyticAt
 
 variable {𝕜 : Type*} [NontriviallyNormedField 𝕜]
 variable {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
@@ -33,3 +35,68 @@ theorem ContDiff.const_smul' {f : E → F} (c : R) (hf : ContDiff 𝕜 n f) :
   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

@@ -78,7 +78,7 @@ theorem partialDeriv_smul₂ {f : E → F} {a : 𝕜} {v : E} : partialDeriv
         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]
+          rw [← smul_assoc, smul_eq_mul, mul_comm, mul_inv_cancel₀ ha]
           simp
         rw [this] at ZZ
         exact hf ZZ
@@ -202,14 +202,14 @@ theorem partialDeriv_compContLin
     left
     intro w
     left
-    rw [fderiv.comp w (ContinuousLinearMap.differentiableAt l) (h w)]
+    rw [fderiv_comp w (ContinuousLinearMap.differentiableAt l) (h w)]
   simp
   rfl
 
 
 theorem partialDeriv_compContLinAt {f : E → F} {l : F →L[𝕜] G} {v : E} {x : E} (h : DifferentiableAt 𝕜 f x) : (partialDeriv 𝕜 v (l ∘ f)) x = (l ∘ partialDeriv 𝕜 v f) x:= by
   unfold partialDeriv
-  rw [fderiv.comp x (ContinuousLinearMap.differentiableAt l) h]
+  rw [fderiv_comp x (ContinuousLinearMap.differentiableAt l) h]
   simp
 
 
@@ -281,7 +281,11 @@ lemma partialDeriv_fderiv {f : E → F} (hf : ContDiff 𝕜 2 f) (z a b : E) :
   unfold partialDeriv
   rw [fderiv_clm_apply]
   · simp
-  · exact (contDiff_succ_iff_fderiv.1 hf).2.differentiable le_rfl z
+  · apply Differentiable.differentiableAt
+    rw [← one_add_one_eq_two] at hf
+    rw [contDiff_succ_iff_fderiv] at hf
+    apply hf.2.2.differentiable
+    simp
   · simp
 
 
@@ -297,8 +301,10 @@ lemma partialDeriv_fderivOn
   rw [fderiv_clm_apply]
   · simp
   · convert DifferentiableOn.differentiableAt _ (IsOpen.mem_nhds hs hz)
-    apply ContDiffOn.differentiableOn _ (Submonoid.oneLE.proof_2 ℕ∞)
-    exact ((contDiffOn_succ_iff_fderiv_of_isOpen hs).1 hf).2
+    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
 
 
@@ -356,11 +362,11 @@ theorem partialDeriv_smul'₂
       left_inv := by
         intro x
         simp
-        rw [← smul_assoc, smul_eq_mul, mul_comm, mul_inv_cancel ha, one_smul]
+        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]
+        rw [← smul_assoc, smul_eq_mul, mul_inv_cancel₀ ha, one_smul]
       continuous_toFun := continuous_const_smul a
       continuous_invFun := continuous_const_smul a⁻¹
     }
@@ -407,7 +413,8 @@ theorem partialDeriv_comm
     let f'' := (fderiv ℝ f' z)
     have h₁ : HasFDerivAt f' f'' z := by
       apply DifferentiableAt.hasFDerivAt
-      apply (contDiff_succ_iff_fderiv.1 h).right.differentiable (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₂
 
@@ -441,8 +448,9 @@ theorem partialDeriv_commOn
     have h₁ : HasFDerivAt f' f'' z := by
       apply DifferentiableAt.hasFDerivAt
       apply DifferentiableOn.differentiableAt _ (IsOpen.mem_nhds hs hz)
-      apply ContDiffOn.differentiableOn _ (Submonoid.oneLE.proof_2 ℕ∞)
-      exact ((contDiffOn_succ_iff_fderiv_of_isOpen hs).1 h).2
+      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
@@ -463,7 +471,9 @@ theorem partialDeriv_commAt
   (h : ContDiffAt ℝ 2 f z) :
   ∀ v₁ v₂ : E, partialDeriv ℝ v₁ (partialDeriv ℝ v₂ f) z = partialDeriv ℝ v₂ (partialDeriv ℝ v₁ f) z := by
 
-  obtain ⟨u, hu₁, hu₂⟩ := h.contDiffOn le_rfl
+  let A := h.contDiffOn le_rfl
+  simp at A
+  obtain ⟨u, hu₁, hu₂⟩ := A
   obtain ⟨v, hv₁, hv₂, hv₃⟩ := mem_nhds_iff.1 hu₁
 
   intro v₁ v₂

Nevanlinna/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

@@ -3,12 +3,16 @@ 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
@@ -36,10 +40,27 @@ lemma l₂ {x : ℝ} : ‖(circleMap 0 1 x) - a‖ = ‖1 - (circleMap 0 1 (-x))
     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 * Real.pi, Real.log ‖circleMap 0 1 x - a‖ = 0 := by
+  ∫ (x : ℝ) in (0)..2 * π, log ‖circleMap 0 1 x - a‖ = 0 := by
 
   by_cases h₁a : a = 0
   · -- case: a = 0
@@ -48,16 +69,16 @@ lemma int₀
 
   -- case: a ≠ 0
   simp_rw [l₂]
-  have {x : ℝ} : Real.log ‖1 - circleMap 0 1 (-x) * a‖ = (fun w ↦ Real.log ‖1 - circleMap 0 1 (w) * a‖) (-x) := by rfl
+  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 ↦ Real.log ‖1 - circleMap 0 1 (w) * a‖))]
+  rw [intervalIntegral.integral_comp_neg ((fun w ↦ log ‖1 - circleMap 0 1 (w) * a‖))]
 
-  let f₁ := fun w ↦ Real.log ‖1 - circleMap 0 1 w * a‖
-  have {x : ℝ} : Real.log ‖1 - circleMap 0 1 x * a‖ = f₁ (x + 2 * Real.pi) := by
+  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
@@ -68,18 +89,18 @@ lemma int₀
     arg 1
     intro x
     rw [this]
-  rw [intervalIntegral.integral_comp_add_right f₁ (2 * Real.pi)]
+  rw [intervalIntegral.integral_comp_add_right f₁ (2 * π)]
   simp
   dsimp [f₁]
 
   let ρ := ‖a‖⁻¹
   have hρ : 1 < ρ := by
-    apply one_lt_inv_iff.mpr
+    apply one_lt_inv_iff₀.mpr
     constructor
-    · exact norm_pos_iff'.mpr h₁a
+    · exact norm_pos_iff.mpr h₁a
     · exact mem_ball_zero_iff.mp ha
 
-  let F := fun z ↦ Real.log ‖1 - z * a‖
+  let F := fun z ↦ log ‖1 - z * a‖
 
   have hf : ∀ x ∈ Metric.ball 0 ρ, HarmonicAt F x := by
     intro x hx
@@ -94,20 +115,23 @@ lemma int₀
       _ < ρ * ‖a‖ := by
         apply (mul_lt_mul_right _).2
         exact mem_ball_zero_iff.mp hx
-        exact norm_pos_iff'.mpr h₁a
+        exact norm_pos_iff.mpr h₁a
       _ = 1 := by
         dsimp [ρ]
-        apply inv_mul_cancel
+        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 Real.zero_lt_one hρ hf
+  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
@@ -141,34 +165,67 @@ lemma int₁₁ : ∫ (x : ℝ) in (0)..π, log (4 * sin x ^ 2) = 0 := by
   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
 
-  have {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 * Real.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
-  simp_rw [this]
+  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
@@ -191,22 +248,88 @@ lemma int₁ :
   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 * Real.pi), log ‖circleMap 0 1 x - a‖ = 0 := by
+  ∫ x in (0)..(2 * π), log ‖circleMap 0 1 x - a‖ = 0 := by
 
   simp_rw [l₂]
-  have {x : ℝ} : Real.log ‖1 - circleMap 0 1 (-x) * a‖ = (fun w ↦ Real.log ‖1 - circleMap 0 1 (w) * a‖) (-x) := by rfl
+  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 ↦ Real.log ‖1 - circleMap 0 1 (w) * a‖))]
+  rw [intervalIntegral.integral_comp_neg ((fun w ↦ log ‖1 - circleMap 0 1 (w) * a‖))]
 
-  let f₁ := fun w ↦ Real.log ‖1 - circleMap 0 1 w * a‖
-  have {x : ℝ} : Real.log ‖1 - circleMap 0 1 x * a‖ = f₁ (x + 2 * Real.pi) := by
+  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
@@ -217,7 +340,7 @@ lemma int₂
     arg 1
     intro x
     rw [this]
-  rw [intervalIntegral.integral_comp_add_right f₁ (2 * Real.pi)]
+  rw [intervalIntegral.integral_comp_add_right f₁ (2 * π)]
   simp
   dsimp [f₁]
 
@@ -249,3 +372,162 @@ lemma int₂
     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

@@ -1,5 +1,6 @@
 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
@@ -23,7 +24,7 @@ lemma logsinBound : ∀ x ∈ (Set.Icc 0 1), ‖(log ∘ sin) x‖ ≤ ‖log ((
     exact zero_lt_two
     apply (Set.mem_Icc.1 hx).1
     simp
-    apply mul_le_one
+    apply mul_le_one₀
     rw [div_le_one pi_pos]
     exact two_le_pi
     exact (Set.mem_Icc.1 hx).1
@@ -69,7 +70,7 @@ lemma logsinBound : ∀ x ∈ (Set.Icc 0 1), ‖(log ∘ sin) x‖ ≤ ‖log ((
         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 inv_mul_cancel₀
         apply div_ne_zero_iff.mpr
         constructor
         · exact pi_ne_zero
@@ -87,7 +88,7 @@ lemma logsinBound : ∀ x ∈ (Set.Icc 0 1), ‖(log ∘ sin) x‖ ≤ ‖log ((
 
     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
+    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₅
@@ -104,6 +105,8 @@ lemma intervalIntegrable_log_sin₁ : IntervalIntegrable (log ∘ sin) volume 0
 
   have int_log : IntervalIntegrable (fun x ↦ ‖log x‖) volume 0 1 := by
     apply IntervalIntegrable.norm
+    -- Extract lemma here: log is integrable on [0, 1], and in fact on any
+    -- interval [a, b]
     rw [← neg_neg log]
     apply IntervalIntegrable.neg
     apply intervalIntegrable_deriv_of_nonneg (g := fun x ↦ -(x * log x - x))
@@ -254,6 +257,19 @@ theorem intervalIntegral.integral_congr_volume
   _ = 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 := π)]

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]

README.md

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

lake-manifest.json

@@ -1,52 +1,32 @@
 {"version": "1.1.0",
  "packagesDir": ".lake/packages",
  "packages":
- [{"url": "https://github.com/leanprover-community/batteries",
-   "type": "git",
-   "subDir": null,
-   "scope": "leanprover-community",
-   "rev": "41bc768e2224d6c75128a877f1d6e198859b3178",
-   "name": "batteries",
-   "manifestFile": "lake-manifest.json",
-   "inputRev": "main",
-   "inherited": true,
-   "configFile": "lakefile.lean"},
-  {"url": "https://github.com/leanprover-community/quote4",
-   "type": "git",
-   "subDir": null,
-   "scope": "leanprover-community",
-   "rev": "01ad33937acd996ee99eb74eefb39845e4e4b9f5",
-   "name": "Qq",
-   "manifestFile": "lake-manifest.json",
-   "inputRev": "master",
-   "inherited": true,
-   "configFile": "lakefile.lean"},
-  {"url": "https://github.com/leanprover-community/aesop",
-   "type": "git",
-   "subDir": null,
-   "scope": "leanprover-community",
-   "rev": "6058ab8d938c5104eace7d0fb5ac17b21cb067b1",
-   "name": "aesop",
-   "manifestFile": "lake-manifest.json",
-   "inputRev": "master",
-   "inherited": true,
-   "configFile": "lakefile.toml"},
-  {"url": "https://github.com/leanprover-community/ProofWidgets4",
-   "type": "git",
-   "subDir": null,
-   "scope": "leanprover-community",
-   "rev": "c87908619cccadda23f71262e6898b9893bffa36",
-   "name": "proofwidgets",
-   "manifestFile": "lake-manifest.json",
-   "inputRev": "v0.0.40",
-   "inherited": true,
-   "configFile": "lakefile.lean"},
-  {"url": "https://github.com/leanprover/lean4-cli",
+ [{"url": "https://github.com/leanprover-community/mathlib4.git",
    "type": "git",
    "subDir": null,
    "scope": "",
-   "rev": "2cf1030dc2ae6b3632c84a09350b675ef3e347d0",
-   "name": "Cli",
+   "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,
@@ -55,21 +35,61 @@
    "type": "git",
    "subDir": null,
    "scope": "leanprover-community",
-   "rev": "e7e90d90a62e6d12cbb27cbbfc31c094ee4ecc58",
+   "rev": "ed3b856bd8893ade75cafe13e8544d4c2660f377",
    "name": "importGraph",
    "manifestFile": "lake-manifest.json",
+   "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,
+   "scope": "leanprover-community",
+   "rev": "a4a08d92be3de00def5298059bf707c72dfd3c66",
+   "name": "aesop",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "master",
+   "inherited": true,
+   "configFile": "lakefile.toml"},
+  {"url": "https://github.com/leanprover-community/quote4",
+   "type": "git",
+   "subDir": null,
+   "scope": "leanprover-community",
+   "rev": "ad942fdf0b15c38bface6acbb01d63855a2519ac",
+   "name": "Qq",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "v4.14.0",
+   "inherited": true,
+   "configFile": "lakefile.lean"},
+  {"url": "https://github.com/leanprover-community/batteries",
+   "type": "git",
+   "subDir": null,
+   "scope": "leanprover-community",
+   "rev": "f007bfe46ea8fb801ec907df9ab540054abcc5fd",
+   "name": "batteries",
+   "manifestFile": "lake-manifest.json",
    "inputRev": "main",
    "inherited": true,
    "configFile": "lakefile.toml"},
-  {"url": "https://github.com/leanprover-community/mathlib4.git",
+  {"url": "https://github.com/leanprover/lean4-cli",
    "type": "git",
    "subDir": null,
-   "scope": "",
-   "rev": "d56e389960165aa122e7c97c098d67e4def09470",
-   "name": "mathlib",
+   "scope": "leanprover",
+   "rev": "0c8ea32a15a4f74143e4e1e107ba2c412adb90fd",
+   "name": "Cli",
    "manifestFile": "lake-manifest.json",
-   "inputRev": null,
-   "inherited": false,
-   "configFile": "lakefile.lean"}],
+   "inputRev": "main",
+   "inherited": true,
+   "configFile": "lakefile.toml"}],
  "name": "nevanlinna",
  "lakeDir": ".lake"}

lean-toolchain

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