File size: 11,242 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
import OAI.AlgebraicGeometry.AbelianModuli.ReferenceFamily.Frame.Finiteness
import OAI.AlgebraicGeometry.AbelianModuli.HilbertConstruction.Constant.GroupIsomorphisms
import OAI.AlgebraicGeometry.AbelianModuli.HilbertConstruction.Level.BaseChange
import OAI.AlgebraicGeometry.AbelianModuli.ReferenceFamily.Level.Data

/-! # Labels -/

namespace OAI.AlgebraicGeometry.AbelianModuli.ReferenceFamily.Frame.Labels.LevelCover

noncomputable section

/-! Over a chosen torsion trivialization, the universal independent frame
gives a locally constant change of basis. The invertibility is proved by
testing relations on nonempty open subschemes. -/

open _root_.CategoryTheory _root_.AlgebraicGeometry
open scoped _root_.CategoryTheory.MonObj _root_.Topology

abbrev Coefficients (g N : ℕ) := Multiplicative (Fin (2 * g) → ZMod N)

theorem coefficients_pow {g N : ℕ} (c : Coefficients g N) : c ^ N = 1 := by
  apply Multiplicative.toAdd.injective
  change N • c.toAdd = 0
  ext i
  simp [nsmul_eq_mul]

variable {S : Scheme} {g N : ℕ} (A : HilbertConstruction.Abelian.Schemes.AbelianScheme g S)

def frameSectionHom (T : Over S) (f : T ⟶ Level.Cover.LevelCover.frameScheme A N) :
    Coefficients g N →* (T ⟶ A.scheme) :=
  ReferenceFamily.Finite.Frames.LevelCover.frameHom (fun i => f ≫ Level.Cover.LevelCover.frameInclusion A N ≫ Level.Cover.LevelCover.coordinate A N i)
    (fun i => by rw [← MonObj.comp_pow, Level.Cover.LevelCover.frame_coordinate_pow, MonObj.comp_one])

theorem frameSectionHom_torsion (T : Over S) (f : T ⟶ Level.Cover.LevelCover.frameScheme A N)
    (c : Coefficients g N) : frameSectionHom A T f c ^ N = 1 :=
  (map_pow (frameSectionHom A T f) c N).symm.trans
    ((congrArg (frameSectionHom A T f) (coefficients_pow c)).trans (map_one _))

def frameTorsionHom (T : Over S) (f : T ⟶ Level.Cover.LevelCover.frameScheme A N) :
    Coefficients g N →* A.torsionPoints N T where
  toFun c := ⟨frameSectionHom A T f c, frameSectionHom_torsion A T f c⟩
  map_one' := Subtype.ext (map_one (frameSectionHom A T f))
  map_mul' c d := Subtype.ext (map_mul (frameSectionHom A T f) c d)

theorem frameTorsionHom_val [NeZero N] (T : Over S) (f : T ⟶ Level.Cover.LevelCover.frameScheme A N)
    (c : Coefficients g N) :
    (frameTorsionHom A T f c).val = (f ≫ Level.Cover.LevelCover.frameInclusion A N) ≫ Level.Cover.LevelCover.relation A N c.toAdd := by
  change ReferenceFamily.Finite.Frames.LevelCover.frameHom _ _ (Multiplicative.ofAdd c.toAdd) = _
  rw [ReferenceFamily.Finite.Frames.LevelCover.frameHom_apply]
  change _ = A.pointsPullback (f ≫ Level.Cover.LevelCover.frameInclusion A N) (∏ i, Level.Cover.LevelCover.coordinate A N i ^ (c.toAdd i).val)
  rw [map_prod]
  simp only [map_pow, HilbertConstruction.Abelian.Schemes.AbelianScheme.pointsPullback_apply, Category.assoc]

theorem frameTorsionHom_natural [NeZero N] {T U : Over S}
    (j : U ⟶ T) (f : T ⟶ Level.Cover.LevelCover.frameScheme A N) (c : Coefficients g N) :
    A.torsionPullback N j (frameTorsionHom A T f c) = frameTorsionHom A U (j ≫ f) c := by
  apply Subtype.ext
  change j ≫ (frameTorsionHom A T f c).val = (frameTorsionHom A U (j ≫ f) c).val
  rw [frameTorsionHom_val, frameTorsionHom_val]
  simp only [Category.assoc]

def frameChangeHom (α : A.FullLevel N) (T : Over S) (f : T ⟶ Level.Cover.LevelCover.frameScheme A N) :
    Coefficients g N →* LocallyConstant T.left (Coefficients g N) :=
  ((α.inv.app (.op T)).hom).comp (frameTorsionHom A T f)

theorem frameChangeHom_natural [NeZero N] (α : A.FullLevel N) {T U : Over S}
    (j : U ⟶ T) (f : T ⟶ Level.Cover.LevelCover.frameScheme A N) (c : Coefficients g N) :
    frameChangeHom A α U (j ≫ f) c =
      (frameChangeHom A α T f c).comap ⟨j.left, j.left.continuous⟩ := by
  have h := ConcreteCategory.congr_hom (α.inv.naturality j.op) (frameTorsionHom A T f c)
  change α.inv.app (.op U) (A.torsionPullback N j (frameTorsionHom A T f c)) = _ at h
  rw [frameTorsionHom_natural] at h
  exact h

def frameChangeAt (α : A.FullLevel N) (T : Over S) (f : T ⟶ Level.Cover.LevelCover.frameScheme A N) (t : T.left) :
    Coefficients g N →* Coefficients g N :=
  (LocallyConstant.evalMonoidHom t).comp (frameChangeHom A α T f)

/-- Independence on every nonempty test forces the change-of-basis
matrix at each ordinary scheme point to be injective. -/
theorem frameChangeAt_injective [NeZero N] (α : A.FullLevel N)
    (T : Over S) (f : T ⟶ Level.Cover.LevelCover.frameScheme A N) (t : T.left) :
    Function.Injective (frameChangeAt A α T f t) := by
  apply (MonoidHom.ker_eq_bot_iff _).mp
  apply le_antisymm ?_ bot_le
  intro c hc
  change c = 1
  by_contra hne
  let d := frameChangeHom A α T f c
  let O : T.left.Opens := ⟨{x | d x = 1}, d.isLocallyConstant.isOpen_fiber 1⟩
  let U : Over S := Over.mk (O.ι ≫ T.hom)
  let j : U ⟶ T := Over.homMk O.ι rfl
  have ht : t ∈ O := hc
  have : Nonempty U.left := ⟨⟨t, ht⟩⟩
  have hz : frameChangeHom A α U (j ≫ f) c = 1 := by
    rw [frameChangeHom_natural]
    apply LocallyConstant.ext
    intro x
    exact x.property
  have hz' : frameTorsionHom A U (j ≫ f) c = 1 := by
    apply ((α.app (.op U)).symm.groupIsoToMulEquiv).injective
    exact hz.trans (map_one _).symm
  have hrel := congrArg Subtype.val hz'
  rw [frameTorsionHom_val] at hrel
  exact Level.Cover.LevelCover.frame_relations_nonzero A N U (j ≫ f) c.toAdd
    (fun h => hne (Multiplicative.toAdd.injective h)) hrel

def frameChangeEquiv [NeZero N] (α : A.FullLevel N) (T : Over S)
    (f : T ⟶ Level.Cover.LevelCover.frameScheme A N) (t : T.left) : Coefficients g N ≃* Coefficients g N :=
  MulEquiv.ofBijective (frameChangeAt A α T f t)
    ((Finite.injective_iff_bijective).mp (frameChangeAt_injective A α T f t))

/-- The changes of basis vary locally constantly, including on
disconnected and nonreduced schemes. -/
def frameChangeLabels [NeZero N] (α : A.FullLevel N) (T : Over S)
    (f : T ⟶ Level.Cover.LevelCover.frameScheme A N) :
    LocallyConstant T.left (Coefficients g N ≃* Coefficients g N) where
  toFun := frameChangeEquiv A α T f
  isLocallyConstant := by
    apply (IsLocallyConstant.iff_eventually_eq _).mpr
    intro t
    have h : ∀ᶠ u in 𝓝 t, ∀ c : Coefficients g N,
        frameChangeHom A α T f c u = frameChangeHom A α T f c t :=
      Filter.eventually_all.mpr (fun c =>
        (frameChangeHom A α T f c).isLocallyConstant.eventually_eq t)
    exact h.mono (fun _ hu => MulEquiv.ext hu)

/-- A map into the frame scheme constructs a full level on the actual
base-changed abelian scheme, using the proved invertible label change. -/
def fullLevelFromFrame [NeZero N] (α : A.FullLevel N) (T : Over S)
    (f : T ⟶ Level.Cover.LevelCover.frameScheme A N) : (A.pullback T.hom).FullLevel N :=
  HilbertConstruction.Constant.GroupIsomorphisms.constantGroupIsoOfLabels (frameChangeLabels A α T f) ≪≫ α.pullback T.hom

def identityTestOver (T : Over S) : Over S :=
  (Over.map T.hom).obj (Over.mk (𝟙 T.left))

def identityTestTo (T : Over S) : identityTestOver T ⟶ T :=
  Over.homMk (𝟙 T.left) (by simp [identityTestOver])

/-- Reconstructed full levels send every constant coefficient vector to
the section defined by the original frame, after the actual pullback
identification. This is a compatibility theorem, not constructor data. -/
theorem fullLevelFromFrame_coefficients [NeZero N] (α : A.FullLevel N)
    (T : Over S) (f : T ⟶ Level.Cover.LevelCover.frameScheme A N) (c : Coefficients g N) :
    A.torsionBaseChangeEquiv T.hom (Over.mk (𝟙 T.left)) N
      ((fullLevelFromFrame A α T f).hom.app (.op (Over.mk (𝟙 T.left)))
        (LocallyConstant.const T.left c)) =
      A.torsionPullback N (identityTestTo T) (frameTorsionHom A T f c) := by
  let e := A.torsionBaseChangeEquiv T.hom (Over.mk (𝟙 T.left)) N
  let β := HilbertConstruction.Constant.GroupIsomorphisms.constantGroupIsoOfLabels (frameChangeLabels A α T f)
  have hlabels : β.hom.app (.op (Over.mk (𝟙 T.left))) (LocallyConstant.const T.left c) =
      frameChangeHom A α T f c := by
    apply LocallyConstant.ext
    intro x
    rfl
  change e (e.symm (α.hom.app (.op (identityTestOver T))
    (β.hom.app (.op (Over.mk (𝟙 T.left))) (LocallyConstant.const T.left c)))) = _
  refine (e.apply_symm_apply _).trans ?_
  refine (congrArg (fun d => α.hom.app (.op (identityTestOver T)) d) hlabels).trans ?_
  have hn := ConcreteCategory.congr_hom (α.hom.naturality (identityTestTo T).op)
    (frameChangeHom A α T f c)
  have hid : (frameChangeHom A α T f c).comap
      ⟨(identityTestTo T).left, (identityTestTo T).left.continuous⟩ =
        frameChangeHom A α T f c := by ext x; rfl
  change α.hom.app (.op (identityTestOver T))
      ((frameChangeHom A α T f c).comap
        ⟨(identityTestTo T).left, (identityTestTo T).left.continuous⟩) =
    A.torsionPullback N (identityTestTo T)
      (α.hom.app (.op T) (frameChangeHom A α T f c)) at hn
  rw [hid] at hn
  have hcancel : α.hom.app (.op T) (frameChangeHom A α T f c) = frameTorsionHom A T f c :=
    (α.app (.op T)).groupIsoToMulEquiv.apply_symm_apply _
  exact hn.trans (congrArg (A.torsionPullback N (identityTestTo T)) hcancel)

/-- In particular the finite etale frame scheme has its constructed
universal full level whenever the torsion is trivialized on the base. -/
def universalSplitFrameLevel [NeZero N] (α : A.FullLevel N) :
    (A.pullback (Level.Cover.LevelCover.frameScheme A N).hom).FullLevel N :=
  fullLevelFromFrame A α (Level.Cover.LevelCover.frameScheme A N) (𝟙 _)

/-- A full-level isomorphism is determined by its constant sections on
the base. Naturality and locally constant decomposition handle all tests. -/
theorem fullLevel_ext_on_constants (α β : A.FullLevel N)
    (h : ∀ c : Coefficients g N,
      α.hom.app (.op (Over.mk (𝟙 S))) (LocallyConstant.const S c) =
        β.hom.app (.op (Over.mk (𝟙 S))) (LocallyConstant.const S c)) : α = β := by
  apply (Level.Data.framesEquivAut α).injective
  apply Iso.ext
  apply HilbertConstruction.Constant.GroupMaps.constantGroupMap_ext
  intro s
  apply MonoidHom.ext
  intro c
  change LocallyConstant.toFun
      (α.inv.app (.op (Over.mk (𝟙 S)))
        (α.hom.app (.op (Over.mk (𝟙 S))) (LocallyConstant.const S c))) s =
    LocallyConstant.toFun
      (α.inv.app (.op (Over.mk (𝟙 S)))
        (β.hom.app (.op (Over.mk (𝟙 S))) (LocallyConstant.const S c))) s
  exact congrArg (fun v => LocallyConstant.toFun (α.inv.app (.op (Over.mk (𝟙 S))) v) s) (h c)

/-- Reconstruction is independent of the initially chosen trivialization.
This compatibility is needed when the split constructions are descended. -/
theorem fullLevelFromFrame_independent [NeZero N] (α β : A.FullLevel N)
    (T : Over S) (f : T ⟶ Level.Cover.LevelCover.frameScheme A N) :
    fullLevelFromFrame A α T f = fullLevelFromFrame A β T f := by
  apply fullLevel_ext_on_constants
  intro c
  apply (A.torsionBaseChangeEquiv T.hom (Over.mk (𝟙 T.left)) N).injective
  exact (fullLevelFromFrame_coefficients A α T f c).trans
    (fullLevelFromFrame_coefficients A β T f c).symm

end

end OAI.AlgebraicGeometry.AbelianModuli.ReferenceFamily.Frame.Labels.LevelCover