Download data/lean/OAI/AlgebraicGeometry/PELModuli/IntegralModel/PEL/Has.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 9.63 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/PELModuli/IntegralModel/PEL/Has.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/AlgebraicGeometry/PELModuli/IntegralModel/PEL/Has.lean
-
curl -L -o Has.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/PELModuli/IntegralModel/PEL/Has.lean
9.63 kB
| import OAI.AlgebraicGeometry.PELModuli.IntegralModel.Base | |
| import OAI.AlgebraicGeometry.PELModuli.IntegralModel.Reduction | |
| import OAI.AlgebraicGeometry.AbelianModuli.ReferenceFamily.Models | |
| import OAI.AlgebraicGeometry.AbelianModuli.HilbertConstruction.Level.BaseChange | |
| /-! # Has -/ | |
| namespace OAI.AlgebraicGeometry.PELModuli.IntegralModel | |
| noncomputable section | |
| /-! | |
| Integral PEL objects and actual comparisons of their generic fibers. | |
| These reuse ReferenceFamily's Hermitian datum, ring action, Rosati condition, and | |
| dual-number Lie eigenspaces, and HilbertConstruction's polarized abelian schemes. | |
| A comparison is an isomorphism of the underlying abelian and dual schemes | |
| preserving the actual polarization, Poincare class, full level, and action. | |
| It is not a cohomology-comparison or model-existence assertion. The existence | |
| of an integral model with this comparison remains in the theorem conclusion. | |
| -/ | |
| open _root_.CategoryTheory _root_.CategoryTheory.Limits _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] | |
| def Base.ArithmeticBaseExtension.integralEmbedding | |
| {K : Type} [Field K] [NumberField K] {ΞΊ : K β+* β} | |
| (B : Base.ArithmeticBaseExtension K ΞΊ) (iota : E β+* K) : | |
| NumberField.RingOfIntegers E β+* B.R := | |
| (algebraMap (NumberField.RingOfIntegers B.extension.carrier) B.R).comp | |
| (NumberField.RingOfIntegers.mapRingHom | |
| ((algebraMap K B.extension.carrier).comp iota)) | |
| omit [NumberField E] [Algebra β E] [NumberField.IsCMField E] in | |
| theorem Base.ArithmeticBaseExtension.integralEmbedding_toField | |
| {K : Type} [Field K] [NumberField K] {ΞΊ : K β+* β} | |
| (B : Base.ArithmeticBaseExtension K ΞΊ) (iota : E β+* K) | |
| (a : NumberField.RingOfIntegers E) : | |
| B.toField (B.integralEmbedding iota a) = | |
| algebraMap K B.extension.carrier (iota (a : E)) := by | |
| change ArithmeticGeometry.Models.Algebra.Constructions.Foundations.integersAwayToField B.extension.carrier | |
| B.denominator B.denominator_ne_zero | |
| (algebraMap (NumberField.RingOfIntegers B.extension.carrier) B.R _) = _ | |
| rw [ArithmeticGeometry.Models.Algebra.Constructions.Foundations.integersAwayToField_algebraMap] | |
| rfl | |
| /-- Polarized abelian data with an actual integral action, over any base. -/ | |
| structure PEL.Has.PolarizedActionData (E : Type) [Field E] (g : β) | |
| (Ξ΄ : Fin g β β) (N : β) (S : Scheme) where | |
| polarized : AbelianModuli.HilbertConstruction.PolarizationData.PolarizedAbelianWithFullLevel g Ξ΄ N S | |
| action : AbelianModuli.ReferenceFamily.ActionData.IntegralAction (NumberField.RingOfIntegers E) polarized.abelian | |
| variable {g N : β} {Ξ΄ : Fin g β β} {S T Z : Scheme} | |
| /-- An isomorphism of two pulled-back PEL families on a common base. | |
| All compatibility clauses are equalities of the specified geometric data. -/ | |
| structure PEL.Has.PulledBackPELDataIso | |
| (A : PEL.Has.PolarizedActionData E g Ξ΄ N S) (B : PEL.Has.PolarizedActionData E g Ξ΄ N T) | |
| (f : Z βΆ S) (h : Z βΆ T) where | |
| abelian : (A.polarized.abelian.pullback f).scheme β | |
| (B.polarized.abelian.pullback h).scheme | |
| dual : (A.polarized.dual.abelian.pullback f).scheme β | |
| (B.polarized.dual.abelian.pullback h).scheme | |
| abelianGroup : IsMonHom abelian.hom | |
| dualGroup : IsMonHom dual.hom | |
| polarization : (Over.pullback f).map A.polarized.polarization.isogeny.hom β« dual.hom = | |
| abelian.hom β« (Over.pullback h).map B.polarized.polarization.isogeny.hom | |
| poincare : AbelianModuli.HilbertConstruction.Line.Bundles.LineBundle.pullbackClass | |
| ((dual.hom ββ abelian.hom).left β« AbelianModuli.HilbertConstruction.PolarizationData.poincareBaseChangeMap B.polarized.dual h) | |
| (AbelianModuli.HilbertConstruction.Line.Bundles.LineBundle.classOf B.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) | |
| level : β (V : Over Z) | |
| (c : LocallyConstant V.left (Multiplicative (Fin (2 * g) β ZMod N))), | |
| ((A.polarized.level.pullback f).hom.app (.op V) c).val β« abelian.hom = | |
| ((B.polarized.level.pullback h).hom.app (.op V) c).val | |
| action : β a : NumberField.RingOfIntegers E, | |
| (A.action.pullback f).map a β« abelian.hom = | |
| abelian.hom β« (B.action.pullback h).map a | |
| attribute [instance] PEL.Has.PulledBackPELDataIso.abelianGroup PEL.Has.PulledBackPELDataIso.dualGroup | |
| def PEL.Has.PulledBackPELDataIso.refl | |
| (A : PEL.Has.PolarizedActionData E g Ξ΄ N S) (f : Z βΆ S) : | |
| PEL.Has.PulledBackPELDataIso A A f f where | |
| abelian := Iso.refl _ | |
| dual := Iso.refl _ | |
| abelianGroup := inferInstanceAs (IsMonHom (π (A.polarized.abelian.pullback f).scheme)) | |
| dualGroup := inferInstanceAs (IsMonHom (π (A.polarized.dual.abelian.pullback f).scheme)) | |
| polarization := (Category.comp_id _).trans (Category.id_comp _).symm | |
| poincare := by simp | |
| level V c := by simp | |
| action a := by simp | |
| variable {s : β} (P : AbelianModuli.ReferenceFamily.Datum.RankThreePELDatum E s) | |
| /-- The integral Lie condition uses the base's O_E-algebra map, so that it | |
| also makes sense in positive characteristic. -/ | |
| def PEL.Has.HasIntegralLieRanks (R : Type) [CommRing R] | |
| (iotaO : NumberField.RingOfIntegers E β+* R) | |
| (T : Over (Spec (.of R))) (A : AbelianModuli.HilbertConstruction.Abelian.Schemes.AbelianScheme (3 * s) T.left) | |
| (Ο : AbelianModuli.ReferenceFamily.ActionData.IntegralAction (NumberField.RingOfIntegers E) A) : Prop := | |
| β (F : Type) [Field F] [IsAlgClosed F] (j : R β+* F) | |
| (p : Spec (.of F) βΆ T.left), | |
| p β« T.hom = Spec.map (CommRingCat.ofHom j) β | |
| β Ο : E ββ[β] E, | |
| AbelianModuli.ReferenceFamily.LieRanks.HasLieRank (A.pullback p) (Ο.pullback p) | |
| (j.comp (iotaO.comp (NumberField.RingOfIntegers.mapRingHom Ο.toRingHom))) | |
| (P.lieRank Ο) | |
| /-- An actual integral PEL object. These are objects of the moduli problem; | |
| representability, smoothness of the moduli space, and spreading are not fields. -/ | |
| structure PEL.Has.IntegralPELObject (R : Type) [CommRing R] | |
| (iotaO : NumberField.RingOfIntegers E β+* R) (N : β) | |
| (T : Over (Spec (.of R))) where | |
| data : PEL.Has.PolarizedActionData E (3 * s) P.polarizationType N T.left | |
| rosati : AbelianModuli.ReferenceFamily.ActionData.RosatiConjugation data.polarized data.action | |
| lieRanks : PEL.Has.HasIntegralLieRanks P R iotaO T data.polarized.abelian data.action | |
| def PEL.Has.characteristicZeroPELData | |
| {K : Type} [Field K] [NumberField K] {iota : E β+* K} | |
| {M : Over (Spec (.of K))} (U : AbelianModuli.ReferenceFamily.PEL.Objects.PELObject P iota N M) : | |
| PEL.Has.PolarizedActionData E (3 * s) P.polarizationType N M.left where | |
| polarized := U.polarized | |
| action := U.action | |
| /-- Adapter to ReferenceFamily's concrete fine-moduli predicate. -/ | |
| def PEL.Has.IsFinePELModuli | |
| {K : Type} [Field K] [NumberField K] (iota : E β+* K) | |
| (N : β) (M : Over (Spec (.of K))) (U : AbelianModuli.ReferenceFamily.PEL.Objects.PELObject P iota N M) : Prop := | |
| (AbelianModuli.ReferenceFamily.Models.FinePELModel.mk M U).IsFine | |
| /-- Explicit fine full-level and stabilizer condition. No coprimality with | |
| the polarization degree is imposed: auxiliary level is handled by ReferenceFamily. -/ | |
| def PEL.Has.IsSufficientlyDeepFullLevel (N : β) : Prop := | |
| 3 β€ N β§ | |
| β g : NumberTheory.ArithmeticGroups.Data.CongruenceLevel.VE E ββ[E] NumberTheory.ArithmeticGroups.Data.CongruenceLevel.VE E, | |
| NumberTheory.ArithmeticGroups.Data.CongruenceLevel.PrincipalLevel P.b P.lattice N g β | |
| β k : β, 0 < k β g ^ k = 1 β g = 1 | |
| /-- A model of the reduced characteristic-zero moduli and its universal | |
| PEL family. The generic identification is a scheme isomorphism, and the | |
| family identification is the explicit geometric isomorphism defined above. -/ | |
| structure PEL.Has.IntegralPELSpread | |
| {K : Type} [Field K] [NumberField K] (iota : E β+* K) (ΞΊ : K β+* β) | |
| (N : β) (M : Over (Spec (.of K))) (U : AbelianModuli.ReferenceFamily.PEL.Objects.PELObject P iota N M) | |
| (B : Base.ArithmeticBaseExtension K ΞΊ) where | |
| toOver : Over B.base | |
| universal : PEL.Has.IntegralPELObject P B.R (B.integralEmbedding iota) N toOver | |
| genericIso : (Over.pullback B.generic).obj toOver β | |
| (Over.pullback B.fieldExtension).obj (Reduction.reduction M) | |
| familyIso : PEL.Has.PulledBackPELDataIso universal.data (PEL.Has.characteristicZeroPELData P U) | |
| (pullback.fst toOver.hom B.generic) | |
| (genericIso.hom.left β« pullback.fst (Reduction.reduction M).hom B.fieldExtension β« | |
| (Reduction.reductionΞΉ M).left) | |
| /-- The restricted fine-moduli property is stated on all actual reduced | |
| test schemes, with pullback classification expressed by the geometric iso. -/ | |
| def PEL.Has.IntegralPELSpread.IsReducedPELModuli | |
| {K : Type} [Field K] [NumberField K] {iota : E β+* K} {ΞΊ : K β+* β} | |
| {N : β} {M : Over (Spec (.of K))} {U : AbelianModuli.ReferenceFamily.PEL.Objects.PELObject P iota N M} | |
| {B : Base.ArithmeticBaseExtension K ΞΊ} (V : PEL.Has.IntegralPELSpread P iota ΞΊ N M U B) : Prop := | |
| β (Y : Over B.base) [IsReduced Y.left] | |
| (A : PEL.Has.IntegralPELObject P B.R (B.integralEmbedding iota) N Y), | |
| β! f : Y βΆ V.toOver, | |
| Nonempty (PEL.Has.PulledBackPELDataIso V.universal.data A.data f.left (π Y.left)) | |
| end | |
| end OAI.AlgebraicGeometry.PELModuli.IntegralModel | |