File size: 4,258 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
import OAI.AlgebraicGeometry.DivisorClass.Chern.Logarithms
import Mathlib.Topology.ContinuousOn

/-! # Logarithms -/

namespace OAI.AlgebraicGeometry.DivisorClass.Chern.Open.Logarithms.Construction

noncomputable section

section

/-!
# ChernClass: continuous logarithms on ambient open neighborhoods

This packages the explicit local complex logarithm on a smaller open subset
of the original space, rather than only on a subtype of an open subset.
-/

open _root_.TopologicalSpace

variable {T : Type*} [TopologicalSpace T]

/-- Actual local logarithm data, including the elementary exponential identity. -/
structure OpenLogarithm (D : Opens T) (g : C(D, ℂ)) (p : D) where
  domain : Opens T
  subset : domain ≤ D
  mem_domain : p.val ∈ domain
  logarithm : C(domain, ℂ)
  exp_logarithm : ∀ q : domain,
    Complex.exp (logarithm q) = g ⟨q.val, subset q.property⟩

/-- The local logarithm is constructed by rotating the slit plane to g(p). -/
def openLogarithm (D : Opens T) (g : C(D, ℂ)) (p : D) (hp : g p ≠ 0) :
    OpenLogarithm D g p := by
  classical
  let F : T → ℂ := fun x => if hx : x ∈ D then g ⟨x, hx⟩ else 0
  have hF : ContinuousOn F (D : Set T) := by
    apply continuousOn_iff_continuous_domRestrict.mpr
    change Continuous (fun x : D => F x.val)
    have heq : (fun x : D => F x.val) = g := by
      funext x
      exact dite_eq_left x.property
    rw [heq]
    exact g.continuous
  let S : Set T := (D : Set T) ∩ (fun x => F x / g p) ⁻¹' Complex.slitPlane
  have hS : IsOpen S :=
    (hF.div_const (g p)).isOpen_inter_preimage D.isOpen Complex.isOpen_slitPlane
  have hpS : p.val ∈ S := by
    refine ⟨p.property, ?_⟩
    change F p.val / g p ∈ Complex.slitPlane
    simp only [F, dite_eq_left p.property, div_self hp, Complex.one_mem_slitPlane]
  have hlog : ContinuousOn (fun x => Complex.log (F x / g p) + Complex.log (g p)) S :=
    (((hF.mono Set.inter_subset_left).div_const (g p)).clog (fun _ hx => hx.2)).add
      continuousOn_const
  refine {
    domain := ⟨S, hS⟩
    subset := Set.inter_subset_left
    mem_domain := hpS
    logarithm := ⟨fun x => Complex.log (F x.val / g p) + Complex.log (g p),
      continuousOn_iff_continuous_domRestrict.mp hlog⟩
    exp_logarithm := ?_ }
  intro q
  change Complex.exp (Complex.log (F q.val / g p) + Complex.log (g p)) = _
  rw [Complex.exp_add, Complex.exp_log (Complex.slitPlane_ne_zero q.property.2),
    Complex.exp_log hp, div_mul_cancel₀ _ hp]
  exact dite_eq_left q.property.1

end

/-!
# ChernClass: local logarithms of nonvanishing changes of frame

Refining each chart near each of its points gives continuous logarithms of a
nonvanishing continuous section on every refined chart.
-/

open _root_.TopologicalSpace

variable {T I : Type} [TopologicalSpace T]

/-- Logarithmic refinement for a family of nonvanishing functions on charts. -/
structure SectionLogRefinement (U : I → Opens T) (g : ∀ i, C(U i, ℂ)) where
  cover : (Σ i, U i) → Opens T
  subset : ∀ a, cover a ≤ U a.1
  logarithm : ∀ a, C(cover a, ℂ)
  exp_logarithm : ∀ a (x : cover a),
    Complex.exp (logarithm a x) = g a.1 ⟨x.val, subset a x.property⟩
  contains_center : ∀ a, a.2.val ∈ cover a

/-- Each refined chart uses the explicit slit-plane logarithm at its center. -/
def sectionLogRefinement (U : I → Opens T) (g : ∀ i, C(U i, ℂ))
    (hg : ∀ i x, g i x ≠ 0) : SectionLogRefinement U g where
  cover a := (openLogarithm (U a.1) (g a.1) a.2 (hg a.1 a.2)).domain
  subset a := (openLogarithm (U a.1) (g a.1) a.2 (hg a.1 a.2)).subset
  logarithm a := (openLogarithm (U a.1) (g a.1) a.2 (hg a.1 a.2)).logarithm
  exp_logarithm a := (openLogarithm (U a.1) (g a.1) a.2 (hg a.1 a.2)).exp_logarithm
  contains_center a := (openLogarithm (U a.1) (g a.1) a.2 (hg a.1 a.2)).mem_domain

theorem sectionLogRefinement_covers (U : I → Opens T) (g : ∀ i, C(U i, ℂ))
    (hg : ∀ i x, g i x ≠ 0) (hc : ∀ x, ∃ i, x ∈ U i) :
    ∀ x, ∃ a, x ∈ (sectionLogRefinement U g hg).cover a := by
  intro x
  obtain ⟨i, hi⟩ := hc x
  exact ⟨⟨i, ⟨x, hi⟩⟩, (sectionLogRefinement U g hg).contains_center ⟨i, ⟨x, hi⟩⟩⟩

end

end OAI.AlgebraicGeometry.DivisorClass.Chern.Open.Logarithms.Construction