math / data /lean /OAI /AlgebraicGeometry /PELModuli /IntegralModel /Reduced /RepresentationAtlas.lean
Download data/lean/OAI/AlgebraicGeometry/PELModuli/IntegralModel/Reduced/RepresentationAtlas.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 12.3 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/PELModuli/IntegralModel/Reduced/RepresentationAtlas.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/AlgebraicGeometry/PELModuli/IntegralModel/Reduced/RepresentationAtlas.lean
-
curl -L -o RepresentationAtlas.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/PELModuli/IntegralModel/Reduced/RepresentationAtlas.lean
12.3 kB
| import OAI.AlgebraicGeometry.PELModuli.IntegralModel.Reduced.OpenRepresentationLifts | |
| import Mathlib.AlgebraicGeometry.Gluing | |
| import Mathlib.AlgebraicGeometry.Limits | |
| import Mathlib.CategoryTheory.Limits.Constructions.Over.Basic | |
| /-! # Representation Atlas -/ | |
| namespace OAI | |
| noncomputable section | |
| namespace AlgebraicGeometry.PELModuli.IntegralModel.Reduced | |
| /-! The triple-overlap maps of reduced local representations, with their | |
| cocycle identity proved by the actual universal values. -/ | |
| set_option backward.isDefEq.respectTransparency false | |
| set_option backward.isDefEq.respectTransparency.types false | |
| open _root_.CategoryTheory _root_.CategoryTheory.Limits _root_.AlgebraicGeometry Opposite | |
| variable {S : Scheme.{0}} {F : (Over S)ᵒᵖ ⥤ Type} {U V W : S.Opens} | |
| (D : OpenRepresentations.ReducedOpenRepresentation F U) (E : OpenRepresentations.ReducedOpenRepresentation F V) | |
| (G : OpenRepresentations.ReducedOpenRepresentation F W) | |
| def OpenRepresentations.ReducedOpenRepresentation.tripleLift {T : Over S} (f : T ⟶ D.overlap E) (g : T ⟶ D.overlap G) : | |
| T ⟶ E.overlap G := | |
| E.overlapLift G (f ≫ D.comparison E ≫ E.inclusion D) (fun t => by | |
| have h := D.overlap_mapsTo_right G (g.left t) | |
| exact (congrArg (fun q : T.left ⟶ S => q t) g.w) ▸ h) | |
| @[reassoc] | |
| theorem OpenRepresentations.ReducedOpenRepresentation.tripleLift_inclusion {T : Over S} (f : T ⟶ D.overlap E) (g : T ⟶ D.overlap G) : | |
| D.tripleLift E G f g ≫ E.inclusion G = f ≫ D.comparison E ≫ E.inclusion D := | |
| E.overlapLift_inclusion G _ _ | |
| def OpenRepresentations.ReducedOpenRepresentation.tripleMap : pullback (D.inclusion E) (D.inclusion G) ⟶ | |
| pullback (E.inclusion G) (E.inclusion D) := | |
| pullback.lift (D.tripleLift E G (pullback.fst _ _) (pullback.snd _ _)) | |
| (pullback.fst _ _ ≫ D.comparison E) (by | |
| rw [OpenRepresentations.ReducedOpenRepresentation.tripleLift_inclusion, Category.assoc]) | |
| @[reassoc] | |
| theorem OpenRepresentations.ReducedOpenRepresentation.tripleMap_snd : D.tripleMap E G ≫ pullback.snd _ _ = | |
| pullback.fst _ _ ≫ D.comparison E := pullback.lift_snd _ _ _ | |
| @[reassoc] | |
| theorem OpenRepresentations.ReducedOpenRepresentation.tripleMap_fst_inclusion : D.tripleMap E G ≫ pullback.fst _ _ ≫ E.inclusion G = | |
| pullback.fst _ _ ≫ D.comparison E ≫ E.inclusion D := by | |
| rw [← Category.assoc, OpenRepresentations.ReducedOpenRepresentation.tripleMap, pullback.lift_fst, OpenRepresentations.ReducedOpenRepresentation.tripleLift_inclusion] | |
| theorem OpenRepresentations.ReducedOpenRepresentation.tripleMap_value {T : Over S} | |
| (f : T ⟶ pullback (D.inclusion E) (D.inclusion G)) : | |
| F.map (f ≫ D.tripleMap E G ≫ pullback.fst _ _ ≫ E.inclusion G).op E.sectionValue = | |
| F.map (f ≫ pullback.fst _ _ ≫ D.inclusion E).op D.sectionValue := by | |
| rw [OpenRepresentations.ReducedOpenRepresentation.tripleMap_fst_inclusion] | |
| simp only [op_comp, F.map_comp, types_comp_apply, OpenRepresentations.ReducedOpenRepresentation.comparison_value] | |
| instance OpenRepresentations.ReducedOpenRepresentation.triple_reduced : IsReduced (pullback (D.inclusion E) (D.inclusion G)).left := by | |
| let p := pullback.fst (D.inclusion E) (D.inclusion G) | |
| have : IsOpenImmersion p.left := MorphismProperty.of_isPullback | |
| ((IsPullback.of_hasPullback (D.inclusion E) (D.inclusion G)).map (Over.forget S)).flip | |
| (D.inclusion_open G) | |
| exact isReduced_of_isOpenImmersion p.left | |
| theorem OpenRepresentations.ReducedOpenRepresentation.tripleMap_cocycle : | |
| D.tripleMap E G ≫ E.tripleMap G D ≫ G.tripleMap D E = 𝟙 _ := by | |
| apply (cancel_mono (pullback.fst (D.inclusion E) (D.inclusion G))).mp | |
| apply (cancel_mono (D.inclusion E)).mp | |
| apply D.hom_ext | |
| simp only [Category.assoc, Category.id_comp] | |
| rw [← Category.assoc (D.tripleMap E G), OpenRepresentations.ReducedOpenRepresentation.tripleMap_value, | |
| Category.assoc, OpenRepresentations.ReducedOpenRepresentation.tripleMap_value] | |
| simpa only [Category.id_comp] using D.tripleMap_value E G (𝟙 _) | |
| end AlgebraicGeometry.PELModuli.IntegralModel.Reduced | |
| namespace AlgebraicGeometry.PELModuli.IntegralModel.Reduced.RepresentationAtlas | |
| section | |
| /-! The actual scheme atlas obtained from local representations on reduced | |
| tests. The transition maps and cocycle are constructed, rather than inputs. -/ | |
| set_option backward.isDefEq.respectTransparency false | |
| set_option backward.isDefEq.respectTransparency.types false | |
| open _root_.CategoryTheory _root_.CategoryTheory.Limits _root_.AlgebraicGeometry Opposite | |
| namespace ReducedRepresentationAtlas | |
| variable {S : Scheme.{0}} {F : (Over S)ᵒᵖ ⥤ Type} {I : Type} {U : I → S.Opens} | |
| (D : ∀ i, OpenRepresentations.ReducedOpenRepresentation F (U i)) | |
| def glueDataOver : CategoryTheory.GlueData (Over S) where | |
| J := I | |
| U i := (D i).space | |
| V p := (D p.1).overlap (D p.2) | |
| f i j := (D i).inclusion (D j) | |
| t i j := (D i).comparison (D j) | |
| t_id i := (D i).comparison_self | |
| t' i j k := (D i).tripleMap (D j) (D k) | |
| t_fac i j k := (D i).tripleMap_snd (D j) (D k) | |
| cocycle i j k := (D i).tripleMap_cocycle (D j) (D k) | |
| def glueData : Scheme.GlueData where | |
| toGlueData := (glueDataOver D).mapGlueData (Over.forget S) | |
| f_open i j := (D i).inclusion_open (D j) | |
| def scheme : Scheme := (glueData D).glued | |
| def chart (i : I) : (D i).space.left ⟶ scheme D := (glueData D).ι i | |
| instance chart_open (i : I) : IsOpenImmersion (chart D i) := | |
| Scheme.GlueData.ι_isOpenImmersion (glueData D) i | |
| def structureMap : scheme D ⟶ S := by | |
| fapply Multicoequalizer.desc | |
| · exact fun i => (D i).space.hom | |
| rintro ⟨i, j⟩ | |
| change ((D i).inclusion (D j)).left ≫ (D i).space.hom = | |
| (((D i).comparison (D j)).left ≫ ((D j).inclusion (D i)).left) ≫ (D j).space.hom | |
| rw [Category.assoc, ((D i).inclusion (D j)).w, ((D j).inclusion (D i)).w, | |
| ((D i).comparison (D j)).w] | |
| @[reassoc] | |
| theorem chart_structureMap (i : I) : chart D i ≫ structureMap D = (D i).space.hom := | |
| Multicoequalizer.π_desc _ _ _ _ _ | |
| def over : Over S := Over.mk (structureMap D) | |
| def chartOver (i : I) : (D i).space ⟶ over D := | |
| Over.homMk (chart D i) (chart_structureMap D i) | |
| theorem charts_cover (z : scheme D) : ∃ i, ∃ x : (D i).space.left, chart D i x = z := | |
| (glueData D).ι_jointly_surjective z | |
| def openCover : (scheme D).OpenCover := (glueData D).openCover | |
| instance reduced : IsReduced (scheme D) := by | |
| have (i : I) : IsReduced ((ReducedRepresentationAtlas.openCover D).X i) := (D i).reduced | |
| exact IsReduced.of_openCover (scheme D) (𝒰 := ReducedRepresentationAtlas.openCover D) | |
| theorem chart_intersection (i j : I) : | |
| IsPullback ((D i).inclusion (D j)).left | |
| (((D i).comparison (D j)).left ≫ ((D j).inclusion (D i)).left) | |
| (chart D i) (chart D j) := | |
| IsPullback.of_isLimit ((glueData D).vPullbackConeIsLimit i j) | |
| theorem chart_glue (i j : I) : | |
| ((D i).comparison (D j)).left ≫ ((D j).inclusion (D i)).left ≫ chart D j = | |
| ((D i).inclusion (D j)).left ≫ chart D i := (glueData D).glue_condition i j | |
| end ReducedRepresentationAtlas | |
| end | |
| section | |
| /-! Each glued parameter chart is the full inverse image of its base open. -/ | |
| set_option backward.isDefEq.respectTransparency false | |
| set_option backward.isDefEq.respectTransparency.types false | |
| open _root_.CategoryTheory _root_.CategoryTheory.Limits _root_.AlgebraicGeometry Opposite | |
| namespace ReducedRepresentationAtlas | |
| variable {S : Scheme.{0}} {F : (Over S)ᵒᵖ ⥤ Type} {I : Type} {U : I → S.Opens} | |
| (D : ∀ i, OpenRepresentations.ReducedOpenRepresentation F (U i)) | |
| theorem chart_range (i : I) : Set.range (chart D i) = | |
| (structureMap D) ⁻¹' (U i : Set S) := by | |
| ext z | |
| constructor | |
| · rintro ⟨x, rfl⟩ | |
| change structureMap D (chart D i x) ∈ U i | |
| have h : structureMap D (chart D i x) = (D i).space.hom x := | |
| congrArg (fun q : (D i).space.left ⟶ S => q x) (chart_structureMap D i) | |
| exact h ▸ (D i).mapsTo x | |
| · intro hz | |
| obtain ⟨j, x, rfl⟩ := charts_cover D z | |
| have hx : (D j).space.hom x ∈ U i := by | |
| have h : structureMap D (chart D j x) = (D j).space.hom x := | |
| congrArg (fun q : (D j).space.left ⟶ S => q x) (chart_structureMap D j) | |
| exact h ▸ hz | |
| let y : ((D j).overlap (D i)).left := ⟨x, hx⟩ | |
| refine ⟨((D i).inclusion (D j)).left (((D j).comparison (D i)).left y), ?_⟩ | |
| exact congrArg (fun q : ((D j).overlap (D i)).left ⟶ scheme D => q y) | |
| (chart_glue D j i) | |
| theorem chart_opensRange (i : I) : (chart D i).opensRange = structureMap D ⁻¹ᵁ U i := | |
| TopologicalSpace.Opens.coe_inj.mp (chart_range D i) | |
| def chartBase (i : I) : (D i).space.left ⟶ (U i).toScheme := | |
| IsOpenImmersion.lift (U i).ι (D i).space.hom (by | |
| rw [Scheme.Opens.range_ι] | |
| rintro _ ⟨x, rfl⟩ | |
| exact (D i).mapsTo x) | |
| @[reassoc] | |
| theorem chartBase_ι (i : I) : chartBase D i ≫ (U i).ι = (D i).space.hom := | |
| IsOpenImmersion.lift_fac _ _ _ | |
| theorem chart_isPullback (i : I) : | |
| IsPullback (chartBase D i) (chart D i) (U i).ι (structureMap D) := by | |
| refine ⟨⟨by rw [chartBase_ι, chart_structureMap]⟩, | |
| ⟨PullbackCone.IsLimit.mk _ ?_ ?_ ?_ ?_⟩⟩ | |
| · intro c | |
| apply IsOpenImmersion.lift (chart D i) c.snd | |
| rw [chart_range] | |
| rintro _ ⟨x, rfl⟩ | |
| change structureMap D (c.snd x) ∈ U i | |
| have h : structureMap D (c.snd x) = (U i).ι (c.fst x) := | |
| congrArg (fun q : c.pt ⟶ S => q x) c.condition.symm | |
| exact h ▸ (c.fst x).property | |
| · intro c | |
| rw [← cancel_mono (U i).ι, Category.assoc, chartBase_ι, | |
| ← chart_structureMap D i, IsOpenImmersion.lift_fac_assoc, c.condition] | |
| · intro c | |
| exact IsOpenImmersion.lift_fac _ _ _ | |
| · intro c m _ h2 | |
| apply (cancel_mono (chart D i)).mp | |
| rw [IsOpenImmersion.lift_fac] | |
| exact h2 | |
| end ReducedRepresentationAtlas | |
| end | |
| /-! Once a global universal value restricts to the local universal values, | |
| its classifier is bijective on every reduced test contained in a base chart. -/ | |
| set_option backward.isDefEq.respectTransparency false | |
| set_option backward.isDefEq.respectTransparency.types false | |
| open _root_.CategoryTheory _root_.AlgebraicGeometry Opposite | |
| namespace ReducedRepresentationAtlas | |
| variable {S : Scheme.{0}} {F : (Over S)ᵒᵖ ⥤ Type} {I : Type} {U : I → S.Opens} | |
| (D : ∀ i, OpenRepresentations.ReducedOpenRepresentation F (U i)) | |
| instance chartOver_mono (i : I) : Mono (chartOver D i) := | |
| (Over.forget S).mono_of_mono_map (show Mono (chartOver D i).left from inferInstanceAs (Mono (chart D i))) | |
| def factorToChart (i : I) {T : Over S} (hT : ∀ t : T.left, T.hom t ∈ U i) | |
| (f : T ⟶ over D) : T ⟶ (D i).space := by | |
| have hr : Set.range f.left ⊆ Set.range (chart D i) := by | |
| rw [chart_range] | |
| rintro _ ⟨t, rfl⟩ | |
| change structureMap D (f.left t) ∈ U i | |
| have ht : structureMap D (f.left t) = T.hom t := congrArg (fun q : T.left ⟶ S => q t) f.w | |
| exact ht ▸ hT t | |
| let q := IsOpenImmersion.lift (chart D i) f.left hr | |
| refine Over.homMk q ?_ | |
| rw [← chart_structureMap D i, IsOpenImmersion.lift_fac_assoc] | |
| exact f.w | |
| theorem factorToChart_chart (i : I) {T : Over S} (hT : ∀ t : T.left, T.hom t ∈ U i) | |
| (f : T ⟶ over D) : factorToChart D i hT f ≫ chartOver D i = f := by | |
| apply Over.OverMorphism.ext | |
| exact IsOpenImmersion.lift_fac _ _ _ | |
| def chartHomEquiv (i : I) (T : Over S) (hT : ∀ t : T.left, T.hom t ∈ U i) : | |
| (T ⟶ over D) ≃ (T ⟶ (D i).space) where | |
| toFun := factorToChart D i hT | |
| invFun f := f ≫ chartOver D i | |
| left_inv := factorToChart_chart D i hT | |
| right_inv f := (cancel_mono (chartOver D i)).mp (factorToChart_chart D i hT (f ≫ chartOver D i)) | |
| theorem classifies_on_base_open (u : F.obj (op (over D))) (i : I) | |
| (hu : F.map (chartOver D i).op u = (D i).sectionValue) | |
| (T : Over S) [IsReduced T.left] (hT : ∀ t : T.left, T.hom t ∈ U i) : | |
| Function.Bijective (fun f : T ⟶ over D => F.map f.op u) := by | |
| have hb := ((D i).classifies T hT).comp (chartHomEquiv D i T hT).bijective | |
| convert hb using 1 | |
| funext f | |
| change F.map f.op u = F.map (factorToChart D i hT f).op (D i).sectionValue | |
| rw [← hu, ← F.map_comp_apply] | |
| exact congrArg (fun q : T ⟶ over D => F.map q.op u) (factorToChart_chart D i hT f).symm | |
| end ReducedRepresentationAtlas | |
| end AlgebraicGeometry.PELModuli.IntegralModel.Reduced.RepresentationAtlas | |
| end | |
| end OAI | |