File size: 7,564 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 | 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
|