Download data/lean/OAI/AlgebraicGeometry/DivisorClass/Chern/Cech/IntegralRefinement.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 11.6 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/DivisorClass/Chern/Cech/IntegralRefinement.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/AlgebraicGeometry/DivisorClass/Chern/Cech/IntegralRefinement.lean
-
curl -L -o IntegralRefinement.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/DivisorClass/Chern/Cech/IntegralRefinement.lean
11.6 kB
| 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 | |