File size: 11,149 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
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
import Mathlib

/-! # Finite Etale -/

namespace OAI.AlgebraicGeometry.GroupSchemes.FiniteEtale

noncomputable section

/-!
# FiniteEtale: geometric objects and their functors of points

A finite commutative group scheme is an actual group object on the spectrum
of a finite-dimensional commutative algebra. A p-divisible group is a tower
of these schemes with closed transition embeddings, the prescribed ranks,
and the defining torsion-kernel condition. That condition is tested on every
affine algebra, including nonreduced algebras.

The standard targets are explicit towers of group-valued functors on affine
algebras. Their isomorphism type is tested naturally on all these algebras;
it is not a classification of geometric points or of Dieudonné modules.
No comparison theorem or classification is assumed in these definitions.
-/

open _root_.CategoryTheory Opposite _root_.AlgebraicGeometry
open _root_.CategoryTheory.MonoidalCategory _root_.CategoryTheory.CartesianMonoidalCategory
open _root_.CategoryTheory.MonObj

universe u

variable (k : Type u) [Field k]

/-- The affine k-scheme represented by a commutative k-algebra. -/
abbrev affine (R : CommAlgCat.{u} k) : Over (Spec (CommRingCat.of k)) :=
  (algSpec (CommRingCat.of k)).obj (op R)

/-- A finite commutative group scheme, with an affine presentation. -/
structure FiniteCommGroupScheme where
  algebra : CommAlgCat.{u} k
  finite : Module.Finite k algebra
  group : CommGrpObj (affine k algebra)

attribute [instance] FiniteCommGroupScheme.finite FiniteCommGroupScheme.group

namespace FiniteCommGroupScheme

variable {k}

abbrev scheme (G : FiniteCommGroupScheme k) := affine k G.algebra

/-- This presentation really gives a finite morphism to Spec k. -/
instance finite_morphism (G : FiniteCommGroupScheme k) : IsFinite G.scheme.hom := by
  change IsFinite (Spec.map (CommRingCat.ofHom (algebraMap k G.algebra)))
  rw [IsFinite.SpecMap_iff]
  exact RingHom.finite_algebraMap.mpr G.finite

/-- Over a field the structure morphism is flat. -/
instance flat_morphism (G : FiniteCommGroupScheme k) : Flat G.scheme.hom := by
  change Flat (Spec.map (CommRingCat.ofHom (algebraMap k G.algebra)))
  rw [Flat.SpecMap_iff]
  exact RingHom.flat_algebraMap_iff.mpr inferInstance

/-- All affine-valued points, retaining infinitesimal structure. -/
def points (G : FiniteCommGroupScheme k) : CommAlgCat.{u} k ⥤ CommGrpCat.{u} where
  obj R := CommGrpCat.of (affine k R ⟶ G.scheme)
  map {R S} f := CommGrpCat.ofHom {
    toFun := fun x => (algSpec (CommRingCat.of k)).map f.op ≫ x
    map_one' := MonObj.comp_one _
    map_mul' := MonObj.comp_mul _ }
  map_id R := by ext x; simp
  map_comp f g := by ext x; simp [Category.assoc]

/-- A group-scheme morphism induces a natural map on all affine points. -/
def mapPoints {G H : FiniteCommGroupScheme k} (f : G.scheme ⟶ H.scheme)
    [IsMonHom f] : G.points ⟶ H.points where
  app R := CommGrpCat.ofHom {
    toFun := fun x => x ≫ f
    map_one' := MonObj.one_comp f
    map_mul' := fun x y => MonObj.mul_comp x y f }
  naturality R S g := by
    apply CommGrpCat.hom_ext
    apply MonoidHom.ext
    intro x
    change ((algSpec (CommRingCat.of k)).map g.op ≫ x) ≫ f =
      (algSpec (CommRingCat.of k)).map g.op ≫ (x ≫ f)
    exact Category.assoc _ _ _

/-- Recover the actual scheme morphism from a natural map on every affine algebra. -/
def morphismOfPoints {G H : FiniteCommGroupScheme k} (α : G.points ⟶ H.points) :
    G.scheme ⟶ H.scheme :=
  (α.app G.algebra) (𝟙 G.scheme)

/-- A natural map on affine points is evaluation of the recovered scheme morphism. -/
theorem morphismOfPoints_apply {G H : FiniteCommGroupScheme k}
    (α : G.points ⟶ H.points) (R : CommAlgCat.{u} k)
    (x : affine k R ⟶ G.scheme) :
    (α.app R) x = x ≫ morphismOfPoints α := by
  let a : op R ⟶ op G.algebra :=
    (algSpec.fullyFaithful (R := CommRingCat.of k)).preimage x
  have ha : (algSpec (CommRingCat.of k)).map a = x :=
    (algSpec.fullyFaithful (R := CommRingCat.of k)).map_preimage x
  have h := ConcreteCategory.congr_hom (α.naturality a.unop) (𝟙 G.scheme)
  change (α.app R) ((algSpec (CommRingCat.of k)).map a ≫ 𝟙 G.scheme) =
    (algSpec (CommRingCat.of k)).map a ≫ morphismOfPoints α at h
  simpa only [ha, Category.comp_id] using h

/-- An isomorphism on all affine-valued points gives an actual scheme isomorphism.
This rules out the loss of infinitesimal information caused by using only k-points. -/
def schemeIsoOfPoints {G H : FiniteCommGroupScheme k} (e : G.points ≅ H.points) :
    G.scheme ≅ H.scheme where
  hom := morphismOfPoints e.hom
  inv := morphismOfPoints e.inv
  hom_inv_id := by
    rw [← morphismOfPoints_apply e.inv G.algebra (morphismOfPoints e.hom)]
    exact ConcreteCategory.congr_hom (NatTrans.congr_app e.hom_inv_id G.algebra)
      (𝟙 G.scheme)
  inv_hom_id := by
    rw [← morphismOfPoints_apply e.hom H.algebra (morphismOfPoints e.inv)]
    exact ConcreteCategory.congr_hom (NatTrans.congr_app e.inv_hom_id H.algebra)
      (𝟙 H.scheme)

end FiniteCommGroupScheme

/-- A tower of affine group functors, with its actual transition maps. -/
structure GroupTower where
  level : ℕ → CommAlgCat.{u} k ⥤ CommGrpCat.{u}
  inclusion : ∀ n, level n ⟶ level (n + 1)

/-- An isomorphism of towers is natural in every algebra and commutes with
the inclusions at every level. -/
structure GroupTower.Iso (G H : GroupTower k) where
  levelIso : ∀ n, G.level n ≅ H.level n
  compatibility : ∀ n,
    G.inclusion n ≫ (levelIso (n + 1)).hom =
      (levelIso n).hom ≫ H.inclusion n

/-- The standard inductive-system definition of a p-divisible group of height h.
Finite flatness is proved above, rather than supplied as an unexplained model.
The image/kernel equality is evaluated on all affine test schemes. -/
structure PDivisibleGroup (p h : ℕ) where
  level : ℕ → FiniteCommGroupScheme k
  inclusion : ∀ n, (level n).scheme ⟶ (level (n + 1)).scheme
  inclusion_hom : ∀ n, IsMonHom (inclusion n)
  inclusion_closed : ∀ n, IsClosedImmersion (inclusion n).left
  rank : ∀ n, Module.finrank k (level n).algebra = p ^ (n * h)
  kernel : ∀ n (R : CommAlgCat.{u} k) (x : affine k R ⟶ (level (n + 1)).scheme),
    (∃ y : affine k R ⟶ (level n).scheme, y ≫ inclusion n = x) ↔ x ^ (p ^ n) = 1

attribute [instance] PDivisibleGroup.inclusion_hom PDivisibleGroup.inclusion_closed

/-- The functor-of-points tower of an actual p-divisible group. -/
def PDivisibleGroup.points {p h : ℕ} (G : PDivisibleGroup k p h) : GroupTower k where
  level n := (G.level n).points
  inclusion n := FiniteCommGroupScheme.mapPoints (G.inclusion n)

/-- The defining kernel condition implies that every level is killed by p^n. -/
theorem PDivisibleGroup.annihilated {p h : ℕ} (G : PDivisibleGroup k p h)
    (n : ℕ) (R : CommAlgCat.{u} k) (x : affine k R ⟶ (G.level n).scheme) :
    x ^ (p ^ n) = 1 := by
  have : Mono (G.inclusion n).left := inferInstance
  have : Mono (G.inclusion n) := Over.mono_of_mono_left (G.inclusion n)
  apply (cancel_mono (G.inclusion n)).mp
  rw [MonObj.pow_comp, MonObj.one_comp]
  exact (G.kernel n R _).mp ⟨x, rfl⟩

/-- The cyclic transition j mod p^n ↦ p*j mod p^(n+1). -/
def cyclicInclusion (p n : ℕ) : ZMod (p ^ n) →+ ZMod (p ^ (n + 1)) :=
  ZMod.lift (p ^ n) ⟨p • Int.castAddHom (ZMod (p ^ (n + 1))), by
    simp only [AddMonoidHom.nsmul_apply, Int.coe_castAddHom, Int.cast_natCast]
    rw [nsmul_eq_mul, ← Nat.cast_mul, ← pow_succ']
    exact ZMod.natCast_self _⟩

@[simp]
theorem cyclicInclusion_intCast (p n : ℕ) (z : ℤ) :
    cyclicInclusion p n (z : ZMod (p ^ n)) = p • (z : ZMod (p ^ (n + 1))) := by
  simp [cyclicInclusion]

/-- The cyclic transition is an actual injection. -/
theorem cyclicInclusion_injective (p n : ℕ) (hp : p ≠ 0) :
    Function.Injective (cyclicInclusion p n) := by
  apply (ZMod.lift_injective (p ^ n)).mpr
  intro z hz
  have hz' : (((p : ℤ) * z : ℤ) : ZMod (p ^ (n + 1))) = 0 := by
    simpa [nsmul_eq_mul] using hz
  rw [ZMod.intCast_zmod_eq_zero_iff_dvd] at hz' ⊢
  simpa only [Nat.cast_pow, Nat.cast_mul, pow_succ', mul_dvd_mul_iff_left (by exact_mod_cast hp :
    (p : ℤ) ≠ 0)] using hz'

/-- The constant cyclic group scheme on affine points. Locally constant
functions are necessary for disconnected test schemes. -/
def etaleLevel (p n : ℕ) : CommAlgCat.{u} k ⥤ CommGrpCat.{u} where
  obj R := CommGrpCat.of (LocallyConstant (PrimeSpectrum R) (Multiplicative (ZMod (p ^ n))))
  map {R S} f := CommGrpCat.ofHom (LocallyConstant.comapMonoidHom
    ⟨PrimeSpectrum.comap f.hom.toRingHom, PrimeSpectrum.continuous_comap _⟩)
  map_id R := by ext x y; simp [PrimeSpectrum.comap_id]
  map_comp f g := by ext x y; rfl

/-- The standard étale tower (Z/p^n)_k, denoted Q_p/Z_p. -/
def etaleTower (p : ℕ) : GroupTower k where
  level := etaleLevel k p
  inclusion n := {
    app R := CommGrpCat.ofHom (LocallyConstant.mapMonoidHom
      (AddMonoidHom.toMultiplicative (cyclicInclusion p n)))
    naturality R S f := by ext x; rfl }

/-- The multiplicative finite group functor on all affine algebras. -/
def multiplicativeLevel (p n : ℕ) : CommAlgCat.{u} k ⥤ CommGrpCat.{u} where
  obj R := CommGrpCat.of (rootsOfUnity (p ^ n) R)
  map {R S} f := CommGrpCat.ofHom (restrictRootsOfUnity f.hom (p ^ n))
  map_id R := by ext x; rfl
  map_comp f g := by ext x; rfl

/-- The standard tower μ_(p^n), denoted μ_(p^∞). -/
def multiplicativeTower (p : ℕ) : GroupTower k where
  level := multiplicativeLevel k p
  inclusion n := {
    app R := CommGrpCat.ofHom (Subgroup.inclusion
      (rootsOfUnity_le_of_dvd (M := R) (pow_dvd_pow p (Nat.le_succ n))))
    naturality R S f := by ext x; rfl }

/-- The multiplicative transition is an actual injection on every affine algebra. -/
theorem multiplicativeTower_injective (p n : ℕ) (R : CommAlgCat.{u} k) :
    Function.Injective ((multiplicativeTower k p).inclusion n |>.app R) := by
  intro x y h
  apply Subtype.ext
  exact congrArg (fun z : rootsOfUnity (p ^ (n + 1)) R => (z : Rˣ)) h

/-- The multiplicative tower has the required torsion kernels on all algebras. -/
theorem multiplicativeTower_kernel (p n : ℕ) (R : CommAlgCat.{u} k)
    (x : ((multiplicativeTower k p).level (n + 1)).obj R) :
    (∃ y : ((multiplicativeTower k p).level n).obj R,
      ((multiplicativeTower k p).inclusion n).app R y = x) ↔ x ^ (p ^ n) = 1 := by
  constructor
  · rintro ⟨y, rfl⟩
    apply Subtype.ext
    exact (mem_rootsOfUnity _ _).mp y.property
  · intro hx
    refine ⟨⟨x.val, ?_⟩, rfl⟩
    exact (mem_rootsOfUnity _ _).mpr (congrArg Subtype.val hx)

/-- The étale transition is an actual injection on every affine algebra. -/
theorem etaleTower_injective (p n : ℕ) (hp : p ≠ 0) (R : CommAlgCat.{u} k) :
    Function.Injective ((etaleTower k p).inclusion n |>.app R) := by
  intro x y h
  apply LocallyConstant.ext
  intro z
  apply cyclicInclusion_injective p n hp
  exact congrArg (fun f : LocallyConstant (PrimeSpectrum R)
    (Multiplicative (ZMod (p ^ (n + 1)))) => f z) h

end

end OAI.AlgebraicGeometry.GroupSchemes.FiniteEtale