Download data/lean/OAI/AlgebraicGeometry/PELModuli/IntegralModel/PEL/BaseChange.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 11.9 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/PELModuli/IntegralModel/PEL/BaseChange.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/AlgebraicGeometry/PELModuli/IntegralModel/PEL/BaseChange.lean
-
curl -L -o BaseChange.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/PELModuli/IntegralModel/PEL/BaseChange.lean
11.9 kB
| import OAI.AlgebraicGeometry.PELModuli.IntegralModel.LieRankPullbackComposition | |
| import OAI.AlgebraicGeometry.AbelianModuli.HilbertConstruction.Moduli.Coherence | |
| /-! # Base Change -/ | |
| namespace OAI.AlgebraicGeometry.PELModuli.IntegralModel.PEL | |
| noncomputable section | |
| section | |
| /-! | |
| Pullback of the actual integral PEL objects. The Rosati equation is | |
| transported through the Poincare bundle; the Lie condition is transported | |
| through the canonical isomorphism of geometric fibers. | |
| -/ | |
| open _root_.CategoryTheory _root_.AlgebraicGeometry | |
| open _root_.CategoryTheory.MonoidalCategory _root_.CategoryTheory.CartesianMonoidalCategory | |
| open scoped _root_.CategoryTheory.MonObj | |
| variable {E : Type} [Field E] [NumberField E] [Algebra β E] | |
| [NumberField.IsCMField E] {g N : β} {Ξ΄ : Fin g β β} {S T : Scheme} | |
| abbrev Has.PolarizedActionData.pullback (A : Has.PolarizedActionData E g Ξ΄ N S) | |
| (f : T βΆ S) : Has.PolarizedActionData E g Ξ΄ N T where | |
| polarized := A.polarized.pullback f | |
| action := A.action.pullback f | |
| omit [NumberField E] [Algebra β E] [NumberField.IsCMField E] in | |
| theorem BaseChange.poincareClass_pullback (A : Has.PolarizedActionData E g Ξ΄ N S) (f : T βΆ S) : | |
| AbelianModuli.HilbertConstruction.Line.Bundles.LineBundle.classOf (A.pullback f).polarized.dual.poincare = | |
| AbelianModuli.HilbertConstruction.Line.Bundles.LineBundle.pullbackClass (AbelianModuli.HilbertConstruction.PolarizationData.poincareBaseChangeMap A.polarized.dual f) | |
| (AbelianModuli.HilbertConstruction.Line.Bundles.LineBundle.classOf A.polarized.dual.poincare) := by | |
| rw [AbelianModuli.HilbertConstruction.Pullback.Comparisons.poincareBaseChangeMap_eq_pullbackOverMap] | |
| rfl | |
| omit [Algebra β E] in | |
| theorem BaseChange.rosati_pullback (A : AbelianModuli.HilbertConstruction.PolarizationData.PolarizedAbelianWithFullLevel g Ξ΄ N S) | |
| (Ο : AbelianModuli.ReferenceFamily.ActionData.IntegralAction (NumberField.RingOfIntegers E) A.abelian) | |
| (hΟ : AbelianModuli.ReferenceFamily.ActionData.RosatiConjugation A Ο) (f : T βΆ S) : | |
| AbelianModuli.ReferenceFamily.ActionData.RosatiConjugation (A.pullback f) (Ο.pullback f) := by | |
| dsimp only [AbelianModuli.ReferenceFamily.ActionData.RosatiConjugation, AbelianModuli.HilbertConstruction.PolarizationData.PolarizedAbelianWithFullLevel.pullback, | |
| AbelianModuli.HilbertConstruction.Dual.Data.DualAbelianData.pullback, AbelianModuli.HilbertConstruction.Abelian.Schemes.AbelianScheme.pullback] | |
| intro a | |
| obtain β¨d, hd, hpoincare, hadjointβ© := hΟ a | |
| let : IsMonHom d := hd | |
| let : GrpObj ((Over.pullback f).obj A.dual.abelian.scheme) := | |
| Functor.grpObjObj (F := Over.pullback f) | |
| let : GrpObj ((Over.pullback f).obj A.abelian.scheme) := | |
| Functor.grpObjObj (F := Over.pullback f) | |
| refine β¨(Over.pullback f).map d, | |
| inferInstanceAs (IsMonHom ((Over.pullback f).map d)), ?_, ?_β© | |
| Β· let A' := (Over.pullback f).obj A.abelian.scheme | |
| let D' := (Over.pullback f).obj A.dual.abelian.scheme | |
| let q : (D' β A').left βΆ (A.dual.abelian.scheme β A.abelian.scheme).left := | |
| (A.dual.poincarePullbackOverMap f).left | |
| let L := AbelianModuli.HilbertConstruction.Line.Bundles.LineBundle.classOf A.dual.poincare | |
| let u : (D' β A').left βΆ (D' β A').left := | |
| ((Over.pullback f).map d ββ π A').left | |
| let v : (D' β A').left βΆ (D' β A').left := | |
| (π D' ββ (Over.pullback f).map (Ο.map a)).left | |
| have hleft : u β« q = q β« (d ββ π A.abelian.scheme).left := by | |
| have hh : ((Over.pullback f).map d ββ | |
| (Over.pullback f).map (π A.abelian.scheme)).left β« q = | |
| q β« (d ββ π A.abelian.scheme).left := | |
| AbelianModuli.HilbertConstruction.Moduli.BaseChange.poincarePullbackOverMap_naturality A.dual A.dual d | |
| (π A.abelian.scheme) f | |
| rw [(Over.pullback f).map_id] at hh | |
| exact hh | |
| have hright : v β« q = q β« (π A.dual.abelian.scheme ββ Ο.map a).left := by | |
| have hh : ((Over.pullback f).map (π A.dual.abelian.scheme) ββ | |
| (Over.pullback f).map (Ο.map a)).left β« q = | |
| q β« (π A.dual.abelian.scheme ββ Ο.map a).left := | |
| AbelianModuli.HilbertConstruction.Moduli.BaseChange.poincarePullbackOverMap_naturality A.dual A.dual | |
| (π A.dual.abelian.scheme) (Ο.map a) f | |
| rw [(Over.pullback f).map_id] at hh | |
| exact hh | |
| change AbelianModuli.HilbertConstruction.Line.Bundles.LineBundle.pullbackClass | |
| u | |
| (AbelianModuli.HilbertConstruction.Line.Bundles.LineBundle.pullbackClass q L) = | |
| AbelianModuli.HilbertConstruction.Line.Bundles.LineBundle.pullbackClass | |
| v | |
| (AbelianModuli.HilbertConstruction.Line.Bundles.LineBundle.pullbackClass q L) | |
| rw [β AbelianModuli.HilbertConstruction.Line.Bundles.LineBundle.pullbackClass_comp, β AbelianModuli.HilbertConstruction.Line.Bundles.LineBundle.pullbackClass_comp, | |
| hleft, hright, AbelianModuli.HilbertConstruction.Line.Bundles.LineBundle.pullbackClass_comp, | |
| AbelianModuli.HilbertConstruction.Line.Bundles.LineBundle.pullbackClass_comp, hpoincare] | |
| Β· exact ((Over.pullback f).map_comp _ _).symm.trans | |
| ((congrArg (fun m β¦ (Over.pullback f).map m) hadjoint).trans | |
| ((Over.pullback f).map_comp _ _)) | |
| variable {s : β} {P : AbelianModuli.ReferenceFamily.Datum.RankThreePELDatum E s} | |
| {R : Type} [CommRing R] {iotaO : NumberField.RingOfIntegers E β+* R} | |
| {X Y : Over (Spec (.of R))} | |
| omit [NumberField E] [NumberField.IsCMField E] in | |
| theorem BaseChange.integralLieRanks_pullback | |
| (A : AbelianModuli.HilbertConstruction.Abelian.Schemes.AbelianScheme (3 * s) X.left) | |
| (Ο : AbelianModuli.ReferenceFamily.ActionData.IntegralAction (NumberField.RingOfIntegers E) A) | |
| (hΟ : Has.HasIntegralLieRanks P R iotaO X A Ο) (f : Y βΆ X) : | |
| Has.HasIntegralLieRanks P R iotaO Y (A.pullback f.left) (Ο.pullback f.left) := by | |
| intro F hF hclosed j p hp Ο | |
| have hcomp : (p β« f.left) β« X.hom = Spec.map (CommRingCat.ofHom j) := by | |
| rw [Category.assoc, f.w, hp] | |
| exact LieRankPullbackComposition.hasLieRank_of_iso (Ο.pullback (p β« f.left)) | |
| ((Ο.pullback f.left).pullback p) _ (A.pullbackCompIso f.left p) | |
| (LieRankPullbackComposition.action_pullbackComp Ο f.left p) _ (hΟ F j (p β« f.left) hcomp Ο) | |
| /-- Every geometric PEL condition is preserved, so this is an actual | |
| object of the same moduli problem on the new test scheme. -/ | |
| def Has.IntegralPELObject.pullback (A : Has.IntegralPELObject P R iotaO N X) | |
| (f : Y βΆ X) : Has.IntegralPELObject P R iotaO N Y where | |
| data := A.data.pullback f.left | |
| rosati := BaseChange.rosati_pullback A.data.polarized A.data.action A.rosati f.left | |
| lieRanks := BaseChange.integralLieRanks_pullback A.data.polarized.abelian A.data.action A.lieRanks f | |
| variable {K : Type} [Field K] [NumberField K] {iota : E β+* K} | |
| {Z : Over (Spec (.of K))} | |
| omit [NumberField E] [NumberField.IsCMField E] [NumberField K] in | |
| /-- Over the characteristic-zero base, the integral signature condition | |
| is exactly the ReferenceFamily condition, on the same geometric fibers. -/ | |
| theorem BaseChange.integralLieRanks_iff_prescribed | |
| (A : AbelianModuli.HilbertConstruction.Abelian.Schemes.AbelianScheme (3 * s) Z.left) | |
| (Ο : AbelianModuli.ReferenceFamily.ActionData.IntegralAction (NumberField.RingOfIntegers E) A) : | |
| Has.HasIntegralLieRanks P K (iota.comp (algebraMap (NumberField.RingOfIntegers E) E)) Z A Ο β | |
| AbelianModuli.ReferenceFamily.PEL.Objects.HasPrescribedLieRanks P iota Z A Ο := by | |
| rfl | |
| def Has.IntegralPELObject.toCharacteristicZero | |
| (A : Has.IntegralPELObject P K | |
| (iota.comp (algebraMap (NumberField.RingOfIntegers E) E)) N Z) : | |
| AbelianModuli.ReferenceFamily.PEL.Objects.PELObject P iota N Z where | |
| polarized := A.data.polarized | |
| action := A.data.action | |
| rosati := A.rosati | |
| lieRanks := BaseChange.integralLieRanks_iff_prescribed _ _ |>.mp A.lieRanks | |
| def BaseChange.integralPELOfCharacteristicZero (A : AbelianModuli.ReferenceFamily.PEL.Objects.PELObject P iota N Z) : | |
| Has.IntegralPELObject P K | |
| (iota.comp (algebraMap (NumberField.RingOfIntegers E) E)) N Z where | |
| data := Has.characteristicZeroPELData P A | |
| rosati := A.rosati | |
| lieRanks := BaseChange.integralLieRanks_iff_prescribed _ _ |>.mpr A.lieRanks | |
| def BaseChange.characteristicZeroPELEquiv : | |
| Has.IntegralPELObject P K (iota.comp (algebraMap (NumberField.RingOfIntegers E) E)) N Z β | |
| AbelianModuli.ReferenceFamily.PEL.Objects.PELObject P iota N Z where | |
| toFun := Has.IntegralPELObject.toCharacteristicZero | |
| invFun := BaseChange.integralPELOfCharacteristicZero | |
| left_inv _ := rfl | |
| right_inv _ := rfl | |
| end | |
| /-! Change of the coefficient ring for the integral PEL problem, and its | |
| actual characteristic-zero generic fiber. -/ | |
| open _root_.CategoryTheory _root_.CategoryTheory.Limits _root_.AlgebraicGeometry | |
| variable {E : Type} [Field E] [NumberField E] [Algebra β E] | |
| [NumberField.IsCMField E] {s N : β} {P : AbelianModuli.ReferenceFamily.Datum.RankThreePELDatum E s} | |
| {R R' : Type} [CommRing R] [CommRing R'] | |
| {iotaO : NumberField.RingOfIntegers E β+* R} {X : Over (Spec (.of R))} | |
| /-- The PEL problem changes base using the same integral action. The Lie | |
| characters are composed with the coefficient-ring homomorphism. -/ | |
| def Has.IntegralPELObject.baseChange (A : Has.IntegralPELObject P R iotaO N X) | |
| (Ο : R β+* R') : | |
| Has.IntegralPELObject P R' (Ο.comp iotaO) N | |
| ((Over.pullback (Spec.map (CommRingCat.ofHom Ο))).obj X) where | |
| data := A.data.pullback (pullback.fst X.hom (Spec.map (CommRingCat.ofHom Ο))) | |
| rosati := BaseChange.rosati_pullback A.data.polarized A.data.action A.rosati _ | |
| lieRanks := by | |
| intro F hF hclosed j p hp Ο | |
| let g := Spec.map (CommRingCat.ofHom Ο) | |
| let q := pullback.fst X.hom g | |
| change p β« pullback.snd X.hom g = Spec.map (CommRingCat.ofHom j) at hp | |
| have hpoint : (p β« q) β« X.hom = Spec.map (CommRingCat.ofHom (j.comp Ο)) := by | |
| rw [Category.assoc, pullback.condition, β Category.assoc, hp, β Spec.map_comp] | |
| rfl | |
| exact LieRankPullbackComposition.hasLieRank_of_iso (A.data.action.pullback (p β« q)) | |
| ((A.data.action.pullback q).pullback p) _ | |
| (A.data.polarized.abelian.pullbackCompIso q p) | |
| (LieRankPullbackComposition.action_pullbackComp A.data.action q p) _ | |
| (A.lieRanks F (j.comp Ο) (p β« q) hpoint Ο) | |
| variable {K : Type} [Field K] [NumberField K] {ΞΊ : K β+* β} | |
| (B : Base.ArithmeticBaseExtension K ΞΊ) (iota : E β+* K) | |
| omit [NumberField E] [Algebra β E] [NumberField.IsCMField E] in | |
| theorem BaseChange.integralEmbedding_generic : | |
| B.toField.comp (B.integralEmbedding iota) = | |
| ((algebraMap K B.extension.carrier).comp iota).comp | |
| (algebraMap (NumberField.RingOfIntegers E) E) := by | |
| ext a | |
| exact B.integralEmbedding_toField iota a | |
| /-- An integral PEL family has an actual ReferenceFamily PEL object as its generic | |
| fiber, with the required scalar action obtained from the integral embedding. -/ | |
| def Has.IntegralPELObject.genericFiber {Y : Over B.base} | |
| (A : Has.IntegralPELObject P B.R (B.integralEmbedding iota) N Y) : | |
| AbelianModuli.ReferenceFamily.PEL.Objects.PELObject P ((algebraMap K B.extension.carrier).comp iota) N | |
| ((Over.pullback B.generic).obj Y) where | |
| polarized := (A.baseChange B.toField).data.polarized | |
| action := (A.baseChange B.toField).data.action | |
| rosati := (A.baseChange B.toField).rosati | |
| lieRanks := by | |
| apply (BaseChange.integralLieRanks_iff_prescribed _ _).mp | |
| rw [β BaseChange.integralEmbedding_generic B iota] | |
| exact (A.baseChange B.toField).lieRanks | |
| theorem Has.IntegralPELObject.genericFiber_data {Y : Over B.base} | |
| (A : Has.IntegralPELObject P B.R (B.integralEmbedding iota) N Y) : | |
| Has.characteristicZeroPELData P (A.genericFiber B iota) = | |
| A.data.pullback (pullback.fst Y.hom B.generic) := rfl | |
| end | |
| end OAI.AlgebraicGeometry.PELModuli.IntegralModel.PEL | |