Mathlib.Analysis.Argument­Principle­Circle

Complex-analysis infrastructure for the argument principle on positively oriented circles: multiplicity-weighted zero counts, logarithmic-derivative contour integrals, homotopy invariance, and Rouché comparison.

Basic 4 core · 1 supporting This module provides the normalized logarithmic-derivative integral around a positively oriented complex circle, the associated multiplicity-weighted zero count in its open disk, and the local factorization behind their ★ normalizedLogDerivCircleIntegral_centeredMonomial

Circle argument-principle definitions and local residue

This module provides the normalized logarithmic-derivative integral around a positively oriented complex circle, the associated multiplicity-weighted zero count in its open disk, and the local factorization behind their relationship.

def normalizedLogDerivCircleIntegral reviewed
Causalean.Mathlib.Analysis.ArgumentPrincipleCircle

For a complex-valued function, a complex center, and a real radius, the normalized logarithmic-derivative circle integral is the integral of the function's logarithmic derivative around the positively oriented circle with that center and radius, divided by 2πi2\pi i.

Definition (Lean source)
f :
ℂ → ℂ
c :
R :
normalizedLogDerivCircleIntegral f c R :
(2 * (Real.pi : ℂ) * I)⁻¹ * circleIntegral (logDeriv f) c R
Causalean.Mathlib.Analysis.ArgumentPrincipleCircle.normalizedLogDerivCircleIntegral · Causalean/Mathlib/Analysis/ArgumentPrincipleCircle/Basic.lean:30
def zeroMultiplicityCount reviewed
Causalean.Mathlib.Analysis.ArgumentPrincipleCircle

For a complex-valued function, a complex center, and a real radius, the zero-multiplicity count is the sum of the analytic multiplicities of all zeros of the function lying strictly inside the open disk with that center and radius, with the standard totalized finite sum used when the support is not finite.

Definition (Lean source)
f :
ℂ → ℂ
c :
R :
zeroMultiplicityCount f c R :
∑ᶠ z : ℂ, if z ∈ ball c R then analyticOrderNatAt f z else 0
Causalean.Mathlib.Analysis.ArgumentPrincipleCircle.zeroMultiplicityCount · Causalean/Mathlib/Analysis/ArgumentPrincipleCircle/Basic.lean:39
def interiorZeros reviewed
Causalean.Mathlib.Analysis.ArgumentPrincipleCircle

For a complex-valued function, a complex center, and a real radius, the interior-zero set consists exactly of the complex numbers that are zeros of the function and lie strictly inside the open disk with that center and radius.

Definition (Lean source)
f :
ℂ → ℂ
c :
R :
interiorZeros f c R :
Set
{z | z ∈ ball c R ∧ f z = 0}
Causalean.Mathlib.Analysis.ArgumentPrincipleCircle.interiorZeros · Causalean/Mathlib/Analysis/ArgumentPrincipleCircle/Basic.lean:47
theorem normalizedLogDerivCircleIntegral_centeredMonomial reviewed
Causalean.Mathlib.Analysis.ArgumentPrincipleCircle

For a positive radius R such that the point a lies strictly inside the open disk of radius R centered at c, the normalized logarithmic-derivative integral around that circle of the monomial z ↦ (z - a)^n equals n.

Formal statement
c a :
R :
n :
hR :
0 < R
ha :
a ∈ ball c R
normalizedLogDerivCircleIntegral (fun z ↦ (z - a) ^ n) c R = (n : ℂ)
Proof (Lean source)
theorem normalizedLogDerivCircleIntegral_centeredMonomial {c a : ℂ} {R : ℝ} {n : ℕ} (hR : 0 < R) (ha : a ∈ ball c R) : normalizedLogDerivCircleIntegral (fun z ↦ (z - a) ^ n) c R = (n : ℂ) := by have hlogDeriv : logDeriv (fun z : ℂ ↦ (z - a) ^ n) = fun z ↦ (n : ℂ) * (z - a)⁻¹ := by funext z rw [logDeriv_fun_pow (by fun_prop)] simp [logDeriv_apply, div_eq_mul_inv] rw [normalizedLogDerivCircleIntegral, hlogDeriv, circleIntegral.integral_const_mul, circleIntegral.integral_sub_inv_of_mem_ball ha] field_simp
Causalean.Mathlib.Analysis.ArgumentPrincipleCircle.normalizedLogDerivCircleIntegral_centeredMonomial · Causalean/Mathlib/Analysis/ArgumentPrincipleCircle/Basic.lean:83 · uses normalizedLogDerivCircleIntegral
1 supporting declaration (lemmas, instances)
  • eventuallyEq_logDeriv_add_order_div_sub theorem — Near a finite-order zero of an analytic complex function, its logarithmic derivative is the zero multiplicity divided by displacement from the zero plus the logarithmic derivative of an analytic factor that does not vanish there.
    f :
    ℂ → ℂ
    a :
    hf :
    AnalyticAt ℂ f a
    hfinite :
    analyticOrderAt f a ≠ ⊤
    ∃ g : ℂ → ℂ,
    conclusion 1
    AnalyticAt ℂ g a
    conclusion 2
    g a ≠ 0
    conclusion 3
    ∀ᶠ z in 𝓝[≠] a, logDeriv f z = (analyticOrderNatAt f a : ℂ) / (z - a) + logDeriv g z
    Proof (Lean source)
    theorem eventuallyEq_logDeriv_add_order_div_sub {f : ℂ → ℂ} {a : ℂ} (hf : AnalyticAt ℂ f a) (hfinite : analyticOrderAt f a ≠ ⊤) : ∃ g : ℂ → ℂ, AnalyticAt ℂ g a ∧ g a ≠ 0 ∧ ∀ᶠ z in 𝓝[≠] a, logDeriv f z = (analyticOrderNatAt f a : ℂ) / (z - a) + logDeriv g z := by obtain ⟨g, hg, hga, hfg⟩ := hf.analyticOrderAt_ne_top.mp hfinite refine ⟨g, hg, hga, ?_⟩ have hg_ne : ∀ᶠ z in 𝓝 a, g z ≠ 0 := hg.continuousAt.eventually_ne hga filter_upwards [hfg.eventuallyEq_nhds.filter_mono inf_le_left, hg.eventually_analyticAt.filter_mono inf_le_left, hg_ne.filter_mono inf_le_left, self_mem_nhdsWithin] with z hz hgz hg_ne_z hza have hlogDeriv : logDeriv f z = logDeriv (fun w : ℂ ↦ (w - a) ^ analyticOrderNatAt f a * g w) z := by have hz' : f =ᶠ[𝓝 z] fun w : ℂ ↦ (w - a) ^ analyticOrderNatAt f a * g w := by simpa only [smul_eq_mul] using hz simp only [logDeriv_apply] rw [hz'.deriv_eq, hz'.self_of_nhds] rw [hlogDeriv, logDeriv_mul (f := fun w : ℂ ↦ (w - a) ^ analyticOrderNatAt f a) (g := g) z (pow_ne_zero (analyticOrderNatAt f a) (sub_ne_zero.mpr hza)) hg_ne_z (by fun_prop) hgz.differentiableAt, logDeriv_fun_pow (by fun_prop)] simp [logDeriv_apply, div_eq_mul_inv]
    Causalean.Mathlib.Analysis.ArgumentPrincipleCircle.eventuallyEq_logDeriv_add_order_div_sub · Causalean/Mathlib/Analysis/ArgumentPrincipleCircle/Basic.lean:54
Argument­Principle 1 core · 5 supporting This module proves the circle argument principle: the normalized logarithmic-derivative integral equals the multiplicity-weighted number of zeros strictly inside the disk. ★ argumentPrinciple_circle

The argument principle for a positively oriented circle

This module proves the circle argument principle: the normalized logarithmic-derivative integral equals the multiplicity-weighted number of zeros strictly inside the disk. It also records its integrality and positivity consequences.

theorem argumentPrinciple_circle reviewed
Causalean.Mathlib.Analysis.ArgumentPrincipleCircle

Argument principle for a circle. For a positive radius R, if the function f is complex-analytic on a neighborhood of the closed disk of radius R centered at c and f is nonzero on the boundary circle, then the normalized logarithmic-derivative integral of f around that circle equals the number of zeros of f strictly inside the disk, counted with analytic multiplicity.

Formal statement
f :
ℂ → ℂ
c :
R :
hR :
0 < R
hf :
hboundary :
∀ z ∈ sphere c R, f z ≠ 0
normalizedLogDerivCircleIntegral f c R = (zeroMultiplicityCount f c R : ℂ)
Proof (Lean source)
theorem argumentPrinciple_circle {f : ℂ → ℂ} {c : ℂ} {R : ℝ} (hR : 0 < R) (hf : AnalyticOnNhd ℂ f (closedBall c R)) (hboundary : ∀ z ∈ sphere c R, f z ≠ 0) : normalizedLogDerivCircleIntegral f c R = (zeroMultiplicityCount f c R : ℂ) := by classical let U := closedBall c R let D := MeromorphicOn.divisor f U let P : ℂ → ℂ := ∏ᶠ u, (· - u) ^ D u let w : ℂ := c + R have hwS : w ∈ sphere c R := by simp [w, abs_of_pos hR] have hwU : w ∈ U := sphere_subset_closedBall hwS have hmw : meromorphicOrderAt f w ≠ ⊤ := by rw [(hf w hwU).meromorphicOrderAt_eq, (hf w hwU).analyticOrderAt_eq_zero.2 (hboundary w hwS)] simp have hfinite : ∀ z ∈ U, meromorphicOrderAt f z ≠ ⊤ := fun z hz ↦ hf.meromorphicOn.meromorphicOrderAt_ne_top_of_isPreconnected (convex_closedBall c R).isPreconnected hwU hz hmw have hDfinite : D.support.Finite := (MeromorphicOn.divisor f U).finiteSupport (isCompact_closedBall c R) obtain ⟨g, hg, hgne, hfg⟩ := hf.meromorphicOn.extract_zeros_poles (fun z ↦ hfinite z z.property) hDfinite have hDnonneg : 0 ≤ D := by simpa [D, U] using MeromorphicOn.AnalyticOnNhd.divisor_nonneg hf have hPan : AnalyticOnNhd ℂ P U := by intro z hz exact Function.FactorizedRational.analyticAt (hDnonneg z) have hPgan : AnalyticOnNhd ℂ (fun z ↦ P z * g z) U := hPan.mul hg have hfg' : f =ᶠ[codiscreteWithin U] fun z ↦ P z * g z := by have h0 : f =ᶠ[codiscreteWithin U] P * g := by simpa [P, U, smul_eq_mul] using hfg exact h0 have hcU : c ∈ U := by simp [U, hR.le] have hlocal : f =ᶠ[𝓝[≠] c] fun z ↦ P z * g z := by change {z | f z = P z * g z} ∈ codiscreteWithin U at hfg' rw [mem_codiscreteWithin_iff_forall_mem_nhdsNE] at hfg' filter_upwards [hfg' c hcU, mem_nhdsWithin_of_mem_nhds (closedBall_mem_nhds c hR)] with z hz hzU exact hz.resolve_right (by simpa [U] using hzU) have heq : EqOn f (fun z ↦ P z * g z) U := hf.eqOn_of_preconnected_of_frequently_eq hPgan (convex_closedBall c R).isPreconnected hcU hlocal.frequently have hDz (z : ℂ) (hz : z ∈ sphere c R) : D z = 0 := by have hzU : z ∈ U := sphere_subset_closedBall hz dsimp [D] rw [MeromorphicOn.divisor_apply hf.meromorphicOn hzU, (hf z hzU).meromorphicOrderAt_eq, (hf z hzU).analyticOrderAt_eq_zero.2 (hboundary z hz)] simp have hlogeq : EqOn (logDeriv f) (fun z ↦ (∑ u ∈ hDfinite.toFinset, (D u : ℂ) * (z - u)⁻¹) + logDeriv g z) (sphere c R) := by intro z hz have hzU : z ∈ U := sphere_subset_closedBall hz have hznb : z ∉ ball c R := by rw [mem_ball, mem_sphere] at * exact not_lt_of_ge hz.ge have hzcl : z ∈ closure (ball c R) := by rw [closure_ball c hR.ne'] exact hzU have hfreq : ∃ᶠ y in 𝓝[≠] z, f y = P y * g y := (mem_closure_ne_iff_frequently_within.mp (by rw [diff_singleton_eq_self hznb] exact hzcl)).mono fun y hy ↦ heq (by exact ball_subset_closedBall hy) have hnear : f =ᶠ[𝓝 z] fun y ↦ P y * g y := ((hf z hzU).frequently_eq_iff_eventually_eq (hPgan z hzU)).mp hfreq calc logDeriv f z = logDeriv (fun y ↦ P y * g y) z := by simp only [logDeriv_apply, hnear.eq_of_nhds, hnear.deriv_eq] _ = logDeriv P z + logDeriv g z := logDeriv_mul z (Function.FactorizedRational.ne_zero (hDz z hz)) (hgne ⟨z, hzU⟩) (hPan z hzU).differentiableAt (hg z hzU).differentiableAt _ = _ := by rw [logDeriv_factorizedRational_eq_sum hDfinite (hDz z hz)] have hloggan : AnalyticOnNhd ℂ (logDeriv g) U := by intro z hz exact (hg.deriv z hz).div (hg z hz) (hgne ⟨z, hz⟩) have hloggzero : circleIntegral (logDeriv g) c R = 0 := (hloggan.differentiableOn.diffContOnCl_ball (by simp [U])).circleIntegral_eq_zero hR.le have hterm (u : ℂ) (hu : u ∈ hDfinite.toFinset) : CircleIntegrable (fun z ↦ (D u : ℂ) * (z - u)⁻¹) c R := by have huD : D u ≠ 0 := by simpa using hu have huS : u ∉ sphere c R := by intro hus exact huD (hDz u hus) exact ((circleIntegrable_sub_inv_iff.mpr (.inr (by simpa [abs_of_pos hR] using huS))).const_mul _) have hsumInt : circleIntegral (fun z ↦ ∑ u ∈ hDfinite.toFinset, (D u : ℂ) * (z - u)⁻¹) c R = ∑ u ∈ hDfinite.toFinset, (D u : ℂ) * (2 * (Real.pi : ℂ) * I) := by rw [circleIntegral.integral_fun_sum hterm] apply Finset.sum_congr rfl intro u hu rw [circleIntegral.integral_const_mul, circleIntegral.integral_sub_inv_of_mem_ball] have huSupp : u ∈ D.support := by simpa using hu have huU : u ∈ U := (MeromorphicOn.divisor f U).supportWithinDomain huSupp have huNS : u ∉ sphere c R := by intro hus exact (show D u ≠ 0 by simpa using hu) (hDz u hus) have huUdist : dist u c ≤ R := by simpa [U, mem_closedBall] using huU have hdistne : dist u c ≠ R := by intro h apply huNS exact h rw [mem_ball] exact lt_of_le_of_ne huUdist hdistne have hloggCI : CircleIntegrable (logDeriv g) c R := hloggan.continuousOn.mono (sphere_subset_closedBall : sphere c R ⊆ U) |>.circleIntegrable hR.le have hcircle : circleIntegral (logDeriv f) c R = ∑ u ∈ hDfinite.toFinset, (D u : ℂ) * (2 * (Real.pi : ℂ) * I) := by rw [circleIntegral.integral_congr hR.le hlogeq, circleIntegral.integral_add (CircleIntegrable.fun_sum _ hterm) hloggCI, hsumInt, hloggzero, add_zero] have hsum : (∑ u ∈ hDfinite.toFinset, (D u : ℂ)) = (zeroMultiplicityCount f c R : ℂ) := by unfold zeroMultiplicityCount rw [finsum_eq_sum_of_support_subset (s := hDfinite.toFinset) (fun u ↦ if u ∈ ball c R then analyticOrderNatAt f u else 0)] · push_cast apply Finset.sum_congr rfl intro u hu have huSupp : u ∈ D.support := by simpa using hu have huU : u ∈ U := (MeromorphicOn.divisor f U).supportWithinDomain huSupp have huNS : u ∉ sphere c R := by intro hus exact (show D u ≠ 0 by simpa using hu) (hDz u hus) have huB : u ∈ ball c R := by have huUdist : dist u c ≤ R := by simpa [U, mem_closedBall] using huU have hdistne : dist u c ≠ R := by intro h apply huNS exact h rw [mem_ball] exact lt_of_le_of_ne huUdist hdistne simp only [huB, if_true] congr 1 dsimp [D] rw [MeromorphicOn.divisor_apply hf.meromorphicOn huU, (hf u huU).meromorphicOrderAt_eq] have haufinite : analyticOrderAt f u ≠ ⊤ := by have hm := hfinite u huU rw [(hf u huU).meromorphicOrderAt_eq] at hm simpa using hm rw [← Nat.cast_analyticOrderNatAt haufinite] simp · intro u hu rw [Function.mem_support] at hu by_cases huB : u ∈ ball c R · have huU : u ∈ U := ball_subset_closedBall huB have haufinite : analyticOrderAt f u ≠ ⊤ := by have hm := hfinite u huU rw [(hf u huU).meromorphicOrderAt_eq] at hm simpa using hm have hDu : D u = (analyticOrderNatAt f u : ℤ) := by dsimp [D] rw [MeromorphicOn.divisor_apply hf.meromorphicOn huU, (hf u huU).meromorphicOrderAt_eq, ← Nat.cast_analyticOrderNatAt haufinite] simp have hnat : analyticOrderNatAt f u ≠ 0 := by simpa [huB] using hu have hDne : D u ≠ 0 := by rw [hDu] exact_mod_cast hnat rw [hDfinite.coe_toFinset, Function.mem_support] exact hDne · simp [huB] at hu rw [normalizedLogDerivCircleIntegral, hcircle, ← Finset.sum_mul, hsum] have hK : (2 * (Real.pi : ℂ) * I) ≠ 0 := by norm_num [Real.pi_ne_zero] rw [mul_comm (zeroMultiplicityCount f c R : ℂ), inv_mul_cancel_left₀ hK]
5 supporting declarations (lemmas, instances)
Homotopy 2 core · 3 supporting This module proves that the normalized logarithmic-derivative count is unchanged along a boundary-zero-free straight-line homotopy, then derives Rouché's standard strict-boundary comparison theorem. ★ rouche_circle

Straight-line homotopy invariance and Rouché's theorem on a circle

This module proves that the normalized logarithmic-derivative count is unchanged along a boundary-zero-free straight-line homotopy, then derives Rouché's standard strict-boundary comparison theorem.

def straightLineHomotopy reviewed
Causalean.Mathlib.Analysis.ArgumentPrincipleCircle

For two complex-valued functions, a real interpolation time, and a complex argument, the straight-line homotopy is the value at that argument of the affine combination giving weight 1t1-t to the first function and weight tt to the second.

Definition (Lean source)
f g :
ℂ → ℂ
t :
z :
straightLineHomotopy f g t z :
(1 - (t : ℂ)) * f z + (t : ℂ) * g z
Causalean.Mathlib.Analysis.ArgumentPrincipleCircle.straightLineHomotopy · Causalean/Mathlib/Analysis/ArgumentPrincipleCircle/Homotopy.lean:28
theorem rouche_circle reviewed
Causalean.Mathlib.Analysis.ArgumentPrincipleCircle

Rouché's theorem for a circle. For a positive radius R, if both f and g are complex-analytic on a neighborhood of the closed disk of radius R centered at c and on the boundary circle the discrepancy ‖g z - f z‖ is everywhere strictly smaller than ‖f z‖, then f and g have the same multiplicity-weighted number of zeros strictly inside the disk.

Formal statement
f g :
ℂ → ℂ
c :
R :
hR :
0 < R
hf :
hg :
hrouche :
∀ z ∈ sphere c R, ‖g z - f z‖ < ‖f z‖
Proof (Lean source)
theorem rouche_circle {f g : ℂ → ℂ} {c : ℂ} {R : ℝ} (hR : 0 < R) (hf : AnalyticOnNhd ℂ f (closedBall c R)) (hg : AnalyticOnNhd ℂ g (closedBall c R)) (hrouche : ∀ z ∈ sphere c R, ‖g z - f z‖ < ‖f z‖) : zeroMultiplicityCount f c R = zeroMultiplicityCount g c R := by apply zeroMultiplicityCount_eq_of_straightLineHomotopy hR hf hg intro t ht z hz hzero have hzero' : f z + (t : ℂ) * (g z - f z) = 0 := by rw [← hzero] simp only [straightLineHomotopy] ring have hfeq : f z = -(t : ℂ) * (g z - f z) := by linear_combination hzero' have hnorm : ‖f z‖ = t * ‖g z - f z‖ := by calc ‖f z‖ = ‖-(t : ℂ) * (g z - f z)‖ := congrArg norm hfeq _ = t * ‖g z - f z‖ := by rw [norm_mul, norm_neg, Complex.norm_real, Real.norm_eq_abs, abs_of_nonneg ht.1] have hle : ‖f z‖ ≤ ‖g z - f z‖ := by rw [hnorm] simpa only [one_mul] using mul_le_mul_of_nonneg_right ht.2 (norm_nonneg (g z - f z)) exact (not_lt_of_ge hle) (hrouche z hz)
Causalean.Mathlib.Analysis.ArgumentPrincipleCircle.rouche_circle · Causalean/Mathlib/Analysis/ArgumentPrincipleCircle/Homotopy.lean:222 · uses zeroMultiplicityCount
3 supporting declarations (lemmas, instances)