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
|