File size: 6,675 Bytes
4a56cd6
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
import Mathlib.Analysis.Meromorphic.FactorizedRational
import Mathlib.Analysis.Complex.Polynomial.Basic
import Mathlib.Algebra.Polynomial.Monic
import Mathlib.Algebra.BigOperators.Fin
import OAI.AlgebraicGeometry.ComplexGroups.HolomorphicAlgebraicity.RootMomentsNe

/-! # Disk Factorization On -/

namespace OAI.AlgebraicGeometry.ComplexGroups.HolomorphicAlgebraicity.DiskFactorizationOn.Constructions.DiskFactorization

noncomputable section

/-!
# Polynomial extraction of zeros on a disk

An analytic function on a neighborhood of a closed disk, nonzero somewhere
in the disk, factors there as a monic polynomial times an analytic unit.
The polynomial is constructed from the actual finite divisor of zeros.
-/

open Set Filter _root_.Metric _root_.Polynomial
open scoped _root_.Topology BigOperators

def divisorPolynomial (D : β„‚ β†’ β„€) (hD : D.HasFiniteSupport) : Polynomial β„‚ :=
  ∏ a ∈ hD.toFinset, (X - C a) ^ (D a).toNat

theorem divisorPolynomial_monic (D : β„‚ β†’ β„€) (hD : D.HasFiniteSupport) :
    (divisorPolynomial D hD).Monic :=
  monic_prod_of_monic _ _ (fun a _ => (monic_X_sub_C a).pow _)

theorem eval_divisorPolynomial (D : β„‚ β†’ β„€) (hD : D.HasFiniteSupport)
    (hDn : βˆ€ a, 0 ≀ D a) (z : β„‚) :
    (divisorPolynomial D hD).eval z = (∏ᢠ a, (· - a) ^ D a) z := by
  rw [finprod_eq_prod_of_mulSupport_subset (s := hD.toFinset)]
  Β· simp only [divisorPolynomial, eval_prod, eval_pow, eval_sub, eval_X, eval_C,
      Finset.prod_apply, Pi.pow_apply]
    apply Finset.prod_congr rfl
    intro a _
    conv_rhs => rw [← Int.toNat_of_nonneg (hDn a), zpow_natCast]
  Β· rw [Function.FactorizedRational.mulSupport]
    intro a ha
    exact hD.mem_toFinset.mpr ha

theorem root_mem_divisor_support (D : β„‚ β†’ β„€) (hD : D.HasFiniteSupport) {z : β„‚}
    (hz : (divisorPolynomial D hD).eval z = 0) : z ∈ Function.support D := by
  simp only [divisorPolynomial, eval_prod, eval_pow, eval_sub, eval_X, eval_C] at hz
  obtain ⟨a, ha, hza⟩ := Finset.prod_eq_zero_iff.mp hz
  have h : z = a := sub_eq_zero.mp (eq_zero_of_pow_eq_zero hza)
  rw [h]
  exact hD.mem_toFinset.mp ha

/-- Continuous functions agreeing off a discrete exceptional set agree on
the whole open domain. -/
theorem eqOn_of_eq_codiscrete {U : Set β„‚} (hU : IsOpen U) {f g : β„‚ β†’ β„‚}
    (hf : βˆ€ x ∈ U, ContinuousAt f x) (hg : βˆ€ x ∈ U, ContinuousAt g x)
    (heq : f =αΆ [codiscreteWithin U] g) : EqOn f g U := by
  intro x hx
  have hne : f =αΆ [𝓝[β‰ ] x] g := by
    have h := (mem_codiscreteWithin_iff_forall_mem_nhdsNE.mp heq) x hx
    filter_upwards [h, mem_nhdsWithin_of_mem_nhds (hU.mem_nhds hx)] with z hz hzU
    rcases hz with hz | hz
    Β· exact hz
    Β· exact False.elim (hz hzU)
  exact tendsto_nhds_unique_of_eventuallyEq
    ((hf x hx).mono_left nhdsWithin_le_nhds)
    ((hg x hx).mono_left nhdsWithin_le_nhds) hne

/-- The zero divisor is finite by compactness and has nonnegative integer
multiplicities by analyticity. Its polynomial extracts exactly these zeros. -/
theorem exists_polynomial_unit_on_disk {f : β„‚ β†’ β„‚} {c : β„‚} {R : ℝ}
    (hf : AnalyticOnNhd β„‚ f (closedBall c R))
    (hn : βˆƒ z ∈ ball c R, f z β‰  0) :
    βˆƒ P : Polynomial β„‚, P.Monic ∧ (βˆ€ z, P.eval z = 0 β†’ z ∈ ball c R) ∧ βˆƒ g : β„‚ β†’ β„‚,
      AnalyticOnNhd β„‚ g (ball c R) ∧ (βˆ€ z ∈ ball c R, g z β‰  0) ∧
      βˆ€ z ∈ ball c R, f z = P.eval z * g z := by
  have hfa := hf.mono ball_subset_closedBall
  obtain ⟨zβ‚€, hzβ‚€, hfzβ‚€βŸ© := hn
  have horderβ‚€ : meromorphicOrderAt f zβ‚€ β‰  ⊀ := by
    rw [(hfa zβ‚€ hzβ‚€).meromorphicNFAt.meromorphicOrderAt_eq_zero_iff.mpr hfzβ‚€]
    exact WithTop.coe_ne_top
  have horder : βˆ€ z ∈ ball c R, meromorphicOrderAt f z β‰  ⊀ := by
    intro z hz
    exact hfa.meromorphicOn.meromorphicOrderAt_ne_top_of_isPreconnected
      (convex_ball c R).isPreconnected hzβ‚€ hz horderβ‚€
  let D : β„‚ β†’ β„€ := MeromorphicOn.divisor f (ball c R)
  have hD : D.HasFiniteSupport := hf.meromorphicOn.divisor_ball_support_finite
  have hDn : βˆ€ a, 0 ≀ D a := MeromorphicOn.AnalyticOnNhd.divisor_nonneg hfa
  let P := divisorPolynomial D hD
  obtain ⟨g, hg, hgn, heq⟩ := hfa.meromorphicOn.extract_zeros_poles
    (fun z => horder z z.property) hD
  refine ⟨P, divisorPolynomial_monic D hD, ?_, g, hg, fun z hz => hgn ⟨z, hz⟩, ?_⟩
  Β· intro z hz
    exact (MeromorphicOn.divisor f (ball c R)).supportWithinDomain
      (root_mem_divisor_support D hD hz)
  Β· apply eqOn_of_eq_codiscrete isOpen_ball
      (fun z hz => (hfa z hz).continuousAt)
      (fun z hz => P.continuous.continuousAt.mul (hg z hz).continuousAt)
    filter_upwards [heq] with z hz
    simpa only [Pi.smul_apply, smul_eq_mul, P, eval_divisorPolynomial D hD hDn] using hz

/-- Enumerate all roots of a monic complex polynomial, with multiplicities. -/
theorem exists_root_tuple (P : Polynomial β„‚) (hP : P.Monic) :
    βˆƒ (d : β„•) (roots : Fin d β†’ β„‚),
      (βˆ€ i, P.eval (roots i) = 0) ∧ βˆ€ z, P.eval z = RootMomentsNe.Constructions.RootMoments.rootProduct roots z := by
  let l := P.roots.toList
  let roots : Fin l.length β†’ β„‚ := l.get
  refine ⟨l.length, roots, ?_, ?_⟩
  Β· intro i
    apply (mem_roots hP.ne_zero).mp
    exact Multiset.mem_toList.mp (List.getElem_mem i.isLt)
  Β· intro z
    rw [(IsAlgClosed.splits P).eval_eq_prod_roots_of_monic hP]
    symm
    change Finset.univ.prod (fun i : Fin l.length => z - l.get i) = _
    rw [← Fin.prod_ofFn]
    change (List.ofFn ((fun a : β„‚ => z - a) ∘ l.get)).prod = _
    rw [← List.map_ofFn, List.ofFn_get]
    change (↑(l.map (fun a => z - a)) : Multiset β„‚).prod = _
    rw [← Multiset.map_coe]
    simp only [l, Multiset.coe_toList]

/-- Actual disk zeros admit a finite tuple factorization suitable for the
contour-moment formulas. No root data are supplied as hypotheses. -/
theorem exists_root_tuple_unit_on_disk {f : β„‚ β†’ β„‚} {c : β„‚} {R : ℝ}
    (hf : AnalyticOnNhd β„‚ f (closedBall c R)) (hn : βˆƒ z ∈ ball c R, f z β‰  0) :
    βˆƒ (d : β„•) (roots : Fin d β†’ β„‚) (g : β„‚ β†’ β„‚),
      (βˆ€ i, roots i ∈ ball c R) ∧ AnalyticOnNhd β„‚ g (ball c R) ∧
      (βˆ€ z ∈ ball c R, g z β‰  0) ∧
      βˆ€ z ∈ ball c R, f z = RootMomentsNe.Constructions.RootMoments.rootProduct roots z * g z := by
  obtain ⟨P, hP, hPr, g, hg, hgn, hfg⟩ := exists_polynomial_unit_on_disk hf hn
  obtain ⟨d, roots, hroots, hPeval⟩ := exists_root_tuple P hP
  refine ⟨d, roots, g, fun i => hPr _ (hroots i), hg, hgn, ?_⟩
  intro z hz
  rw [hfg z hz, hPeval]

end

end OAI.AlgebraicGeometry.ComplexGroups.HolomorphicAlgebraicity.DiskFactorizationOn.Constructions.DiskFactorization