File size: 11,640 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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
import OAI.AlgebraicGeometry.DivisorClass.Chern.Compact.IntegralScaling
import OAI.AlgebraicGeometry.DivisorClass.Chern.LogRefinementOpen

/-! # Integral Refinement -/

namespace OAI.AlgebraicGeometry.DivisorClass.Chern.Cech.IntegralRefinement

noncomputable section

section

/-! Finite shrinking refinements give compact control of every Čech overlap. -/

open _root_.TopologicalSpace

set_option backward.isDefEq.respectTransparency false
set_option backward.isDefEq.respectTransparency.types false
set_option backward.defeqAttrib.useBackward true

variable {T I : Type} [TopologicalSpace T]

structure CompactCechRefinement (U : I β†’ Opens T) where
  charts : Finset I
  cover : charts β†’ Opens T
  closure_subset : βˆ€ i, closure (cover i : Set T) βŠ† U i.val
  covers : βˆ€ x : T, βˆƒ i, x ∈ cover i

theorem nonempty_compactCechRefinement [CompactSpace T] [NormalSpace T]
    (U : I β†’ Opens T) (hU : βˆ€ x : T, βˆƒ i, x ∈ U i) : Nonempty (CompactCechRefinement U) := by
  classical
  obtain ⟨s, hs⟩ := isCompact_univ.elim_finite_subcover
    (fun i => (U i : Set T)) (fun i => (U i).isOpen) (by
      intro x _
      exact Set.mem_iUnion.mpr (hU x))
  have hsc : βˆ€ x : T, βˆƒ i : s, x ∈ U i.val := by
    intro x
    obtain ⟨i, hi⟩ := Set.mem_iUnion.mp (hs (Set.mem_univ x))
    obtain ⟨his, hxi⟩ := Set.mem_iUnion.mp hi
    exact ⟨⟨i, his⟩, hxi⟩
  obtain ⟨V, hVc, hVo, hVU⟩ := exists_subset_iUnion_closure_subset
    (s := (Set.univ : Set T)) isClosed_univ (fun i : s => (U i.val).isOpen)
    (fun x _ => Set.toFinite {i : s | x ∈ U i.val}) (by
      intro x _
      exact Set.mem_iUnion.mpr (hsc x))
  refine ⟨⟨s, fun i => ⟨V i, hVo i⟩, hVU, ?_⟩⟩
  intro x
  exact Set.mem_iUnion.mp (hVc (Set.mem_univ x))

def compactCechRefinement [CompactSpace T] [NormalSpace T]
    (U : I β†’ Opens T) (hU : βˆ€ x : T, βˆƒ i, x ∈ U i) : CompactCechRefinement U :=
  Classical.choice (nonempty_compactCechRefinement U hU)

variable {U : I β†’ Opens T} (r : CompactCechRefinement U)

theorem CompactCechRefinement.subset (i : r.charts) : r.cover i ≀ U i.val :=
  fun _ hx => r.closure_subset i (subset_closure hx)

theorem CompactCechRefinement.intersectionClosure_subset {n : β„•} (a : Fin (n + 1) β†’ r.charts) :
    closure (AlgebraicTopology.DeRham.Comparison.SmoothCech.cechIntersection r.cover a : Set T) βŠ† AlgebraicTopology.DeRham.Comparison.SmoothCech.cechIntersection U (Subtype.val ∘ a) := by
  intro x hx
  apply (AlgebraicTopology.DeRham.Comparison.SmoothCech.mem_cechIntersection U (Subtype.val ∘ a) x).mpr
  intro j
  exact r.closure_subset (a j) (closure_mono (AlgebraicTopology.DeRham.Comparison.SmoothCech.cechIntersection_le r.cover a j) hx)

theorem CompactCechRefinement.intersectionClosure_isCompact [CompactSpace T]
    {n : β„•} (a : Fin (n + 1) β†’ r.charts) :
    IsCompact (closure (AlgebraicTopology.DeRham.Comparison.SmoothCech.cechIntersection r.cover a : Set T)) :=
  isClosed_closure.isCompact

/-- Each original rational section has a common denominator on the whole refined overlap closure. -/
theorem CompactCechRefinement.intersection_clear_denominators [CompactSpace T]
    {n : β„•} (a : Fin (n + 1) β†’ r.charts)
    (f : LocallyConstant (AlgebraicTopology.DeRham.Comparison.SmoothCech.cechIntersection U (Subtype.val ∘ a)) β„š) :
    βˆƒ N : β„•, 0 < N ∧ βˆƒ g : LocallyConstant (AlgebraicTopology.DeRham.Comparison.SmoothCech.cechIntersection r.cover a) β„€,
      βˆ€ x : AlgebraicTopology.DeRham.Comparison.SmoothCech.cechIntersection r.cover a, (g x : β„š) =
        (N : β„š) * f ⟨x.val, r.intersectionClosure_subset a (subset_closure x.property)⟩ := by
  obtain ⟨N, hN, g, hg⟩ := Compact.IntegralScaling.locallyConstant_rat_clear_denominators_on_compact
    (AlgebraicTopology.DeRham.Comparison.SmoothCech.cechIntersection U (Subtype.val ∘ a)) f
    (closure (AlgebraicTopology.DeRham.Comparison.SmoothCech.cechIntersection r.cover a : Set T)) (r.intersectionClosure_isCompact a)
    (r.intersectionClosure_subset a)
  let g' : LocallyConstant (AlgebraicTopology.DeRham.Comparison.SmoothCech.cechIntersection r.cover a) β„€ :=
    ⟨fun x => g ⟨x.val, subset_closure x.property⟩,
      g.isLocallyConstant.comp_continuous (continuous_subtype_val.subtype_mk _)⟩
  exact ⟨N, hN, g', fun x => hg ⟨x.val, subset_closure x.property⟩⟩

end

section

/-! One denominator simultaneously clears all actual overlaps of a finite Čech cochain. -/

open _root_.TopologicalSpace
open scoped BigOperators

set_option backward.isDefEq.respectTransparency false
set_option backward.isDefEq.respectTransparency.types false
set_option backward.defeqAttrib.useBackward true

theorem finiteFamily_locallyConstant_integer_scale {I : Type} [Fintype I]
    {T : I β†’ Type} [βˆ€ i, TopologicalSpace (T i)] (f : βˆ€ i, LocallyConstant (T i) β„š)
    (h : βˆ€ i, βˆƒ N : β„•, 0 < N ∧ βˆƒ g : LocallyConstant (T i) β„€,
      βˆ€ x, (g x : β„š) = (N : β„š) * f i x) :
    βˆƒ N : β„•, 0 < N ∧ βˆƒ g : βˆ€ i, LocallyConstant (T i) β„€,
      βˆ€ i x, (g i x : β„š) = (N : β„š) * f i x := by
  classical
  choose d hd g hg using h
  let N := ∏ i, d i
  have hN : 0 < N := Finset.prod_pos (fun i _ => hd i)
  have hdi (i : I) : d i ∣ N := Finset.dvd_prod_of_mem d (Finset.mem_univ i)
  refine ⟨N, hN, fun i => LocallyConstant.map (fun z : β„€ => ((N / d i : β„•) : β„€) * z) (g i), ?_⟩
  intro i x
  change ((((N / d i : β„•) : β„€) * g i x : β„€) : β„š) = (N : β„š) * f i x
  have he : ((N / d i : β„•) : β„š) * d i = (N : β„š) := by
    exact_mod_cast Nat.div_mul_cancel (hdi i)
  simp only [Int.cast_mul, Int.cast_natCast]
  rw [hg i x, ← mul_assoc, he]

variable {T I : Type} [TopologicalSpace T]
variable {U : I β†’ Opens T} (r : CompactCechRefinement U)

theorem CompactCechRefinement.cochain_clear_denominators [CompactSpace T]
    (n : β„•)
    (c : Rational.Cech.RationalCech.CechCochain (Obj.RationalCech.locallyConstantPresheaf (TopCat.of T)) U n) :
    βˆƒ N : β„•, 0 < N ∧
      βˆƒ g : βˆ€ a : Fin (n + 1) β†’ r.charts, LocallyConstant (AlgebraicTopology.DeRham.Comparison.SmoothCech.cechIntersection r.cover a) β„€,
        βˆ€ a (x : AlgebraicTopology.DeRham.Comparison.SmoothCech.cechIntersection r.cover a), (g a x : β„š) =
          (N : β„š) * c (Subtype.val ∘ a)
            ⟨x.val, r.intersectionClosure_subset a (subset_closure x.property)⟩ := by
  classical
  let f (a : Fin (n + 1) β†’ r.charts) : LocallyConstant (AlgebraicTopology.DeRham.Comparison.SmoothCech.cechIntersection r.cover a) β„š :=
    ⟨fun x => c (Subtype.val ∘ a)
      ⟨x.val, r.intersectionClosure_subset a (subset_closure x.property)⟩,
      (c (Subtype.val ∘ a)).isLocallyConstant.comp_continuous (continuous_subtype_val.subtype_mk _)⟩
  exact finiteFamily_locallyConstant_integer_scale f
    (fun a => r.intersection_clear_denominators a (c (Subtype.val ∘ a)))

end

section

/-! Integer Čech cochains with the original alternating open-restriction differential. -/

open _root_.CategoryTheory _root_.TopologicalSpace Opposite
open scoped BigOperators

set_option backward.isDefEq.respectTransparency false
set_option backward.isDefEq.respectTransparency.types false
set_option backward.defeqAttrib.useBackward true

variable {T I : Type} [TopologicalSpace T] (U : I β†’ Opens T)

abbrev IntegerCechCochain (n : β„•) :=
  βˆ€ a : Fin (n + 1) β†’ I, LocallyConstant (AlgebraicTopology.DeRham.Comparison.SmoothCech.cechIntersection U a) β„€

def integerCechRationalize (n : β„•) : IntegerCechCochain U n β†’+
    Rational.Cech.RationalCech.CechCochain (Obj.RationalCech.locallyConstantPresheaf (TopCat.of T)) U n where
  toFun c a := LocallyConstant.mapAddMonoidHom (Int.castAddHom β„š) (c a)
  map_zero' := by
    funext a
    exact map_zero (LocallyConstant.mapAddMonoidHom (Int.castAddHom β„š))
  map_add' c d := by
    funext a
    exact map_add (LocallyConstant.mapAddMonoidHom (Int.castAddHom β„š)) (c a) (d a)

theorem integerCechRationalize_injective (n : β„•) : Function.Injective (integerCechRationalize U n) := by
  intro c d h
  funext a
  apply LocallyConstant.ext
  intro x
  exact Rat.intCast_injective (congrArg (fun f => (f a : LocallyConstant (AlgebraicTopology.DeRham.Comparison.SmoothCech.cechIntersection U a) β„š) x) h)

def integerCechDelta (n : β„•) (c : IntegerCechCochain U n) : IntegerCechCochain U (n + 1) :=
  fun a => βˆ‘ j : Fin (n + 2), (-1 : β„€) ^ j.val β€’
    ((IntegralConstantSheaf.locallyConstantIntegerPresheaf (TopCat.of T)).map
      (homOfLE (AlgebraicTopology.DeRham.Comparison.SmoothCech.cechIntersection_le_precomp U a j.succAbove)).op (c (a ∘ j.succAbove)))

theorem integerCechRationalize_delta (n : β„•) (c : IntegerCechCochain U n) :
    integerCechRationalize U (n + 1) (integerCechDelta U n c) =
      Rational.Cech.RationalCech.cechDelta (Obj.RationalCech.locallyConstantPresheaf (TopCat.of T)) U n
        (integerCechRationalize U n c) := by
  funext a
  change LocallyConstant.mapAddMonoidHom (Int.castAddHom β„š)
    (βˆ‘ j : Fin (n + 2), (-1 : β„€) ^ j.val β€’
      ((IntegralConstantSheaf.locallyConstantIntegerPresheaf (TopCat.of T)).map
        (homOfLE (AlgebraicTopology.DeRham.Comparison.SmoothCech.cechIntersection_le_precomp U a j.succAbove)).op (c (a ∘ j.succAbove)))) = _
  rw [map_sum, Rational.Cech.RationalCech.cechDelta_apply]
  apply Finset.sum_congr rfl
  intro j _
  rw [map_zsmul]
  congr 1

theorem integerCechDelta_squared (n : β„•) (c : IntegerCechCochain U n) :
    integerCechDelta U (n + 1) (integerCechDelta U n c) = 0 := by
  apply integerCechRationalize_injective U (n + 2)
  rw [integerCechRationalize_delta, integerCechRationalize_delta,
    Rational.Cech.RationalCech.cechDelta_squared, map_zero]

end

/-! Every rational Čech cocycle on a compact normal space becomes integral after scaling and refinement. -/

open _root_.CategoryTheory _root_.TopologicalSpace

set_option backward.isDefEq.respectTransparency false
set_option backward.isDefEq.respectTransparency.types false
set_option backward.defeqAttrib.useBackward true

variable {T I : Type} [TopologicalSpace T] [CompactSpace T] [NormalSpace T]

/-- The positive multiplier and the integer cocycle are constructed from the original rational cocycle. -/
theorem exists_integral_cech_refinement (U : I β†’ Opens T) (hU : βˆ€ x : T, βˆƒ i, x ∈ U i)
    (n : β„•)
    (c : Rational.Cech.RationalCech.CechCochain (Obj.RationalCech.locallyConstantPresheaf (TopCat.of T)) U n)
    (hc : Rational.Cech.RationalCech.cechDelta (Obj.RationalCech.locallyConstantPresheaf (TopCat.of T)) U n c = 0) :
    βˆƒ r : CompactCechRefinement U, βˆƒ N : β„•, 0 < N ∧ βˆƒ g : IntegerCechCochain r.cover n,
      integerCechDelta r.cover n g = 0 ∧
      integerCechRationalize r.cover n g = (N : β„š) β€’
        Rational.Cech.RationalCech.cechRefinementMap (Obj.RationalCech.locallyConstantPresheaf (TopCat.of T))
          U r.cover Subtype.val r.subset n c := by
  let r := compactCechRefinement U hU
  obtain ⟨N, hN, g, hg⟩ := r.cochain_clear_denominators n c
  have he : integerCechRationalize r.cover n g = (N : β„š) β€’
      Rational.Cech.RationalCech.cechRefinementMap (Obj.RationalCech.locallyConstantPresheaf (TopCat.of T))
        U r.cover Subtype.val r.subset n c := by
    funext a
    apply LocallyConstant.ext
    intro x
    exact hg a x
  refine ⟨r, N, hN, g, ?_, he⟩
  apply integerCechRationalize_injective r.cover (n + 1)
  rw [integerCechRationalize_delta, he, map_smul,
    ← Rational.Cech.RationalCech.cechRefinementMap_delta, hc, map_zero, smul_zero, map_zero]

end

end OAI.AlgebraicGeometry.DivisorClass.Chern.Cech.IntegralRefinement