math / data /lean /OAI /AlgebraicGeometry /AbelianModuli /ReferenceFamily /Frame /FrameRestriction.lean
Download data/lean/OAI/AlgebraicGeometry/AbelianModuli/ReferenceFamily/Frame/FrameRestriction.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 7.56 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/AbelianModuli/ReferenceFamily/Frame/FrameRestriction.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/AlgebraicGeometry/AbelianModuli/ReferenceFamily/Frame/FrameRestriction.lean
-
curl -L -o FrameRestriction.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/AbelianModuli/ReferenceFamily/Frame/FrameRestriction.lean
7.56 kB
| import OAI.AlgebraicGeometry.AbelianModuli.ReferenceFamily.IndependentFrames | |
| import OAI.AlgebraicGeometry.AbelianModuli.HilbertConstruction.Level.LevelFamilies | |
| /-! # Frame Restriction -/ | |
| namespace OAI.AlgebraicGeometry.AbelianModuli.ReferenceFamily.Frame.FrameRestriction.LevelCover | |
| noncomputable section | |
| /-! Compatibility with HilbertConstruction's actual geometric restriction of full | |
| levels. Classifying frames commute with changes of test scheme. -/ | |
| open _root_.CategoryTheory _root_.CategoryTheory.Limits _root_.AlgebraicGeometry | |
| open scoped _root_.CategoryTheory.MonObj | |
| open OAI.AlgebraicGeometry.AbelianModuli.ReferenceFamily.ConstantSectionsOn.ConstantSections | |
| variable {S : Scheme.{0}} {g N : ℕ} (A : HilbertConstruction.Abelian.Schemes.AbelianScheme g S) | |
| theorem relativeCoefficients_left (T : Over S) | |
| (α : HilbertConstruction.Abelian.Schemes.AbelianScheme.constantLevelFunctor g N T.left ⟶ (A.pullback T.hom).torsionFunctor N) | |
| (c : Labels.LevelCover.Coefficients g N) : | |
| (IndependentFrames.LevelCover.relativeCoefficients A T α c).val.left = | |
| (α.app (.op (ConstantSectionsOn.ConstantSections.baseTest T.left)) (LocallyConstant.const T.left c)).val.left ≫ | |
| pullback.fst A.scheme.hom T.hom := | |
| IndependentFrames.LevelCover.relativePointEquiv_left A T T (𝟙 T) _ | |
| theorem pullbackCongrIso_hom_left_fst {B : Scheme.{0}} (f h : B ⟶ S) (w : f = h) : | |
| (A.pullbackCongrIso f h w).hom.left ≫ pullback.fst A.scheme.hom h = | |
| pullback.fst A.scheme.hom f := by | |
| subst h | |
| exact Category.id_comp _ | |
| theorem level_mappedIdentity_left {B C : Scheme.{0}} {d : ℕ} | |
| (D : HilbertConstruction.Abelian.Schemes.AbelianScheme d B) (α : D.FullLevel N) (f : C ⟶ B) | |
| (c : Multiplicative (Fin (2 * d) → ZMod N)) : | |
| (α.hom.app (.op ((Over.map f).obj (ConstantSectionsOn.ConstantSections.baseTest C))) (LocallyConstant.const C c)).val.left = | |
| (α.hom.app (.op (Over.mk f)) (LocallyConstant.const C c)).val.left := by | |
| let j : Over.mk f ⟶ (Over.map f).obj (ConstantSectionsOn.ConstantSections.baseTest C) := | |
| Over.homMk (𝟙 C) ((Category.id_comp _).trans (Category.id_comp _)) | |
| have hn := ConcreteCategory.congr_hom (α.hom.naturality j.op) (LocallyConstant.const C c) | |
| have hleft := congrArg (fun x : D.torsionPoints N (Over.mk f) => x.val.left) hn | |
| exact ((Category.id_comp _).symm.trans hleft.symm) | |
| /-- Geometric restriction preserves the actual coefficient sections | |
| after forgetting the change of base. -/ | |
| theorem relativeCoefficients_restrict {T U : Over S} (j : T ⟶ U) | |
| (α : (A.pullback U.hom).FullLevel N) (c : Labels.LevelCover.Coefficients g N) : | |
| IndependentFrames.LevelCover.relativeCoefficients A T (α.restrict j).hom c = | |
| A.torsionPullback N j (IndependentFrames.LevelCover.relativeCoefficients A U α.hom c) := by | |
| apply Subtype.ext | |
| apply Over.OverMorphism.ext | |
| rw [relativeCoefficients_left] | |
| let x := ((α.pullback j.left).hom.app (.op (ConstantSectionsOn.ConstantSections.baseTest T.left)) | |
| (LocallyConstant.const T.left c)).val | |
| have hx : x.left ≫ pullback.fst (A.pullback U.hom).scheme.hom j.left = | |
| (α.hom.app (.op ((Over.map j.left).obj (ConstantSectionsOn.ConstantSections.baseTest T.left))) | |
| (LocallyConstant.const T.left c)).val.left := | |
| congrArg Over.Hom.left (α.pullback_basis j.left (ConstantSectionsOn.ConstantSections.baseTest T.left) (LocallyConstant.const T.left c)) | |
| have hcomp := A.pullbackCompIso_inv_left_fst U.hom j.left | |
| have hcongr := pullbackCongrIso_hom_left_fst A (j.left ≫ U.hom) T.hom j.w | |
| have hn := IndependentFrames.LevelCover.relativeCoefficients_natural A U T j α.hom c | |
| have hright : (A.torsionPullback N j (IndependentFrames.LevelCover.relativeCoefficients A U α.hom c)).val.left = | |
| (α.hom.app (.op (Over.mk j.left)) (LocallyConstant.const T.left c)).val.left ≫ | |
| pullback.fst A.scheme.hom U.hom := | |
| (congrArg (fun x : A.torsionPoints N T => x.val.left) hn).trans | |
| (IndependentFrames.LevelCover.relativePointEquiv_left A U T j _) | |
| change ((x.left ≫ (A.pullbackCompIso U.hom j.left).inv.left) ≫ | |
| (A.pullbackCongrIso (j.left ≫ U.hom) T.hom j.w).hom.left) ≫ | |
| pullback.fst A.scheme.hom T.hom = _ | |
| exact (Category.assoc _ _ _).trans | |
| ((congrArg (fun z => (x.left ≫ (A.pullbackCompIso U.hom j.left).inv.left) ≫ z) hcongr).trans | |
| ((Category.assoc _ _ _).trans | |
| ((congrArg (fun z => x.left ≫ z) hcomp).trans | |
| ((Category.assoc _ _ _).symm.trans | |
| ((congrArg (fun z => z ≫ pullback.fst A.scheme.hom U.hom) hx).trans | |
| ((congrArg (fun z => z ≫ pullback.fst A.scheme.hom U.hom) | |
| (level_mappedIdentity_left (A.pullback U.hom) α j.left c)).trans hright.symm)))))) | |
| /-- The unique classifying map for a full level respects the actual | |
| geometric restriction operation, including its pullback comparisons. -/ | |
| theorem frameOfRelativeLevel_restrict [NeZero N] {T U : Over S} (j : T ⟶ U) | |
| (α : (A.pullback U.hom).FullLevel N) : | |
| IndependentFrames.LevelCover.frameOfRelativeLevel A T (α.restrict j) = j ≫ IndependentFrames.LevelCover.frameOfRelativeLevel A U α := by | |
| apply (IndependentFrames.LevelCover.independentFramePointsEquiv A T).injective | |
| apply Subtype.ext | |
| apply MonoidHom.ext | |
| intro c | |
| have hT := IndependentFrames.LevelCover.frameOfRelativeMap_coefficients A T (α.restrict j).hom | |
| (fun V => ((α.restrict j).app (.op V)).groupIsoToMulEquiv.injective) | |
| have hU := IndependentFrames.LevelCover.frameOfRelativeMap_coefficients A U α.hom | |
| (fun V => (α.app (.op V)).groupIsoToMulEquiv.injective) | |
| change Labels.LevelCover.frameTorsionHom A T (IndependentFrames.LevelCover.frameOfRelativeLevel A T (α.restrict j)) c = | |
| Labels.LevelCover.frameTorsionHom A T (j ≫ IndependentFrames.LevelCover.frameOfRelativeLevel A U α) c | |
| exact (congrArg (fun h : Labels.LevelCover.Coefficients g N →* A.torsionPoints N T => h c) hT).trans | |
| ((relativeCoefficients_restrict A j α c).trans | |
| ((congrArg (A.torsionPullback N j) | |
| (congrArg (fun h : Labels.LevelCover.Coefficients g N →* A.torsionPoints N U => h c) hU).symm).trans | |
| (Labels.LevelCover.frameTorsionHom_natural A j (IndependentFrames.LevelCover.frameOfRelativeLevel A U α) c))) | |
| theorem frameOfRelativeLevel_injective [NeZero N] (T : Over S) : | |
| Function.Injective (IndependentFrames.LevelCover.frameOfRelativeLevel (N := N) A T) := by | |
| intro α β h | |
| apply (IndependentFrames.LevelCover.fullLevelFrameIsoEquiv A T).injective | |
| exact Subtype.ext h | |
| /-- The full-level family functor with HilbertConstruction's geometric restriction maps | |
| is defined without a chosen level on the original abelian scheme. The | |
| functor laws follow from the actual classifying frame maps. -/ | |
| def fullLevelFamilyFunctor [NeZero N] : (Over S)ᵒᵖ ⥤ Type 1 where | |
| obj T := (A.pullback T.unop.hom).FullLevel N | |
| map f := TypeCat.ofHom (fun α => α.restrict f.unop) | |
| map_id T := by | |
| ext α | |
| apply frameOfRelativeLevel_injective A T.unop | |
| exact (frameOfRelativeLevel_restrict A (𝟙 T.unop) α).trans (Category.id_comp _) | |
| map_comp {T U V} f h := by | |
| ext α | |
| apply frameOfRelativeLevel_injective A V.unop | |
| exact (frameOfRelativeLevel_restrict A (h.unop ≫ f.unop) α).trans | |
| ((Category.assoc _ _ _).trans | |
| ((congrArg (fun q => h.unop ≫ q) (frameOfRelativeLevel_restrict A f.unop α).symm).trans | |
| (frameOfRelativeLevel_restrict A h.unop (α.restrict f.unop)).symm)) | |
| end | |
| end OAI.AlgebraicGeometry.AbelianModuli.ReferenceFamily.Frame.FrameRestriction.LevelCover | |