File size: 9,634 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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
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