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
|