File size: 8,487 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
import OAI.AlgebraicGeometry.PELModuli.CMPoints.BlocksProjectors

/-! # Block Decomposition -/

namespace OAI.AlgebraicGeometry.PELModuli.CMPoints.BlockDecomposition

noncomputable section

/-! The split integral projectors give a product decomposition of actual
torsion points on every test scheme, including nonreduced schemes. -/

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

variable {S : Scheme} {g : β„•}
  {E K : Type} [Field E] [NumberField E] [Algebra β„š E]
  [Field K] [NumberField K] {ΞΊ : K β†’+* β„‚} {q : β„•} [Fact q.Prime]
  (j : Arithmetic.QadicChoice K ΞΊ q) (iota : E β†’+* K) (hsplit : j.HasSplitCoordinates iota)
  (A : AbelianModuli.HilbertConstruction.Abelian.Schemes.AbelianScheme g S)
  (ρ : AbelianModuli.ReferenceFamily.ActionData.IntegralAction (NumberField.RingOfIntegers E) A)

include hsplit in
theorem action_eq_of_coordinates (n : β„•)
    (b c : NumberField.RingOfIntegers E)
    (hbc : j.residueCoordinates iota n b = j.residueCoordinates iota n c)
    (T : Over S) (x : T ⟢ A.scheme) (hx : x ^ (q ^ n) = 1) :
    x ≫ ρ.map b = x ≫ ρ.map c := by
  apply BlocksProjectors.action_eq_of_congruence A ρ b c (q ^ n) _ T x hx
  rw [Nat.cast_pow, ← (hsplit n).2]
  change j.residueCoordinates iota n (b - c) = 0
  rw [map_sub, hbc, sub_self]

theorem projector_idempotent_on_torsion (n : β„•) (Ο„ : Gal(E/β„š))
    (T : Over S) (x : T ⟢ A.scheme) (hx : x ^ (q ^ n) = 1) :
    (x ≫ ρ.map (j.projector iota hsplit n Ο„)) ≫
      ρ.map (j.projector iota hsplit n Ο„) = x ≫ ρ.map (j.projector iota hsplit n Ο„) := by
  classical
  rw [Category.assoc, ← ρ.map_mul]
  apply action_eq_of_coordinates j iota hsplit A ρ n _ _ _ T x hx
  rw [map_mul, j.projector_coordinates]
  ext Ο…
  by_cases h : Ο… = Ο„ <;> simp [h]

theorem projector_orthogonal_on_torsion (n : β„•) (Ο„ Ο… : Gal(E/β„š)) (h : Ο„ β‰  Ο…)
    (T : Over S) (x : T ⟢ A.scheme) (hx : x ^ (q ^ n) = 1) :
    (x ≫ ρ.map (j.projector iota hsplit n Ο„)) ≫
      ρ.map (j.projector iota hsplit n Ο…) = 1 := by
  classical
  rw [Category.assoc, ← ρ.map_mul]
  have he : j.residueCoordinates iota n
      (j.projector iota hsplit n Ο… * j.projector iota hsplit n Ο„) =
        j.residueCoordinates iota n 0 := by
    rw [map_mul, j.projector_coordinates, j.projector_coordinates, map_zero]
    ext Ξ½
    by_cases hΞ½ : Ξ½ = Ο„
    Β· subst Ξ½
      simp [h]
    Β· simp [hΞ½]
  rw [action_eq_of_coordinates j iota hsplit A ρ n _ 0 he T x hx,
    ρ.map_zero, MonObj.comp_one]

def torsionProjection (n : β„•) (Ο„ : Gal(E/β„š)) (T : Over S) :
    A.torsionPoints (q ^ n) T β†’* BlocksProjectors.blockPoints A ρ (j.localCharacter iota Ο„) n T where
  toFun x := ⟨x.val ≫ ρ.map (j.projector iota hsplit n Ο„),
    (BlocksProjectors.mem_block_iff_fixed j iota hsplit A ρ n Ο„ T _).mpr ⟨by
      have hx : x.val ^ (q ^ n) = 1 := x.property
      rw [← MonObj.pow_comp, hx, MonObj.one_comp],
      projector_idempotent_on_torsion j iota hsplit A ρ n Ο„ T x.val x.property⟩⟩
  map_one' := Subtype.ext (MonObj.one_comp _)
  map_mul' x y := Subtype.ext (MonObj.mul_comp x.val y.val _)

theorem block_projector_self (n : β„•) (Ο„ : Gal(E/β„š)) (T : Over S)
    (x : BlocksProjectors.blockPoints A ρ (j.localCharacter iota Ο„) n T) :
    x.val ≫ ρ.map (j.projector iota hsplit n Ο„) = x.val :=
  ((BlocksProjectors.mem_block_iff_fixed j iota hsplit A ρ n Ο„ T x.val).mp x.property).2

theorem block_projector_other (n : β„•) (Ο„ Ο… : Gal(E/β„š)) (h : Ο„ β‰  Ο…)
    (T : Over S) (x : BlocksProjectors.blockPoints A ρ (j.localCharacter iota Ο„) n T) :
    x.val ≫ ρ.map (j.projector iota hsplit n Ο…) = 1 := by
  have hx := projector_orthogonal_on_torsion j iota hsplit A ρ n Ο„ Ο… h T x.val x.property.1
  rw [block_projector_self j iota hsplit A ρ n Ο„ T x] at hx
  exact hx

omit [NumberField E] [Algebra β„š E] in
theorem integralAction_sum_on_points {Idx : Type*} (s : Finset Idx)
    (b : Idx β†’ NumberField.RingOfIntegers E) (T : Over S) (x : T ⟢ A.scheme) :
    x ≫ ρ.map (βˆ‘ i ∈ s, b i) = ∏ i ∈ s, x ≫ ρ.map (b i) := by
  classical
  induction s using Finset.induction_on with
  | empty => simp only [Finset.sum_empty, Finset.prod_empty, ρ.map_zero, MonObj.comp_one]
  | @insert i s hi ih =>
      rw [Finset.sum_insert hi, Finset.prod_insert hi, ρ.map_add, MonObj.comp_mul, ih]

theorem torsion_projectors_sum (n : β„•) (T : Over S)
    (x : T ⟢ A.scheme) (hx : x ^ (q ^ n) = 1) :
    (∏ Ο„ : Gal(E/β„š), x ≫ ρ.map (j.projector iota hsplit n Ο„)) = x := by
  classical
  rw [← integralAction_sum_on_points A ρ]
  have hs : j.residueCoordinates iota n (βˆ‘ Ο„, j.projector iota hsplit n Ο„) =
      j.residueCoordinates iota n 1 := by
    simp only [map_sum, j.projector_coordinates, map_one]
    ext Ο…
    simp [Finset.sum_apply, Pi.single_apply]
  rw [action_eq_of_coordinates j iota hsplit A ρ n _ 1 hs T x hx, ρ.map_one, Category.comp_id]

def assembleBlocks (n : β„•) (T : Over S) :
    (βˆ€ Ο„ : Gal(E/β„š), BlocksProjectors.blockPoints A ρ (j.localCharacter iota Ο„) n T) β†’*
      A.torsionPoints (q ^ n) T where
  toFun x := ⟨∏ Ο„, (x Ο„).val, by
    change (∏ Ο„, (x Ο„).val) ^ (q ^ n) = 1
    rw [← Finset.prod_pow]
    simp only [(x _).property.1, Finset.prod_const_one]⟩
  map_one' := by apply Subtype.ext; exact Finset.prod_const_one
  map_mul' x y := by apply Subtype.ext; exact Finset.prod_mul_distrib

theorem assemble_torsionProjections (n : β„•) (T : Over S)
    (x : A.torsionPoints (q ^ n) T) :
    assembleBlocks j iota A ρ n T (fun Ο„ => torsionProjection j iota hsplit A ρ n Ο„ T x) = x := by
  apply Subtype.ext
  exact torsion_projectors_sum j iota hsplit A ρ n T x.val x.property

theorem torsionProjection_assemble (n : β„•) (T : Over S)
    (x : βˆ€ Ο„ : Gal(E/β„š), BlocksProjectors.blockPoints A ρ (j.localCharacter iota Ο„) n T) (Ο… : Gal(E/β„š)) :
    torsionProjection j iota hsplit A ρ n Ο… T (assembleBlocks j iota A ρ n T x) = x Ο… := by
  classical
  apply Subtype.ext
  let f : (T ⟢ A.scheme) β†’* (T ⟢ A.scheme) := {
    toFun a := a ≫ ρ.map (j.projector iota hsplit n Ο…)
    map_one' := MonObj.one_comp _
    map_mul' a b := MonObj.mul_comp a b _ }
  change f (∏ Ο„, (x Ο„).val) = (x Ο…).val
  rw [map_prod]
  rw [Finset.prod_eq_single Ο…]
  Β· exact block_projector_self j iota hsplit A ρ n Ο… T (x Ο…)
  Β· intro Ο„ _ hΟ„
    exact block_projector_other j iota hsplit A ρ n Ο„ Ο… hΟ„ T (x Ο„)
  Β· simp

/-- The product decomposition is an isomorphism of actual groups of
torsion points, uniformly over every test scheme. -/
def torsionBlockEquiv (n : β„•) (T : Over S) :
    A.torsionPoints (q ^ n) T ≃*
      (βˆ€ Ο„ : Gal(E/β„š), BlocksProjectors.blockPoints A ρ (j.localCharacter iota Ο„) n T) where
  toFun x Ο„ := torsionProjection j iota hsplit A ρ n Ο„ T x
  invFun := assembleBlocks j iota A ρ n T
  left_inv := assemble_torsionProjections j iota hsplit A ρ n T
  right_inv x := funext (torsionProjection_assemble j iota hsplit A ρ n T x)
  map_mul' x y := funext (fun Ο„ => (torsionProjection j iota hsplit A ρ n Ο„ T).map_mul x y)

def productBlockFunctor (n : β„•) : (Over S)α΅’α΅– β₯€ GrpCat where
  obj T := GrpCat.of (βˆ€ Ο„ : Gal(E/β„š), BlocksProjectors.blockPoints A ρ (j.localCharacter iota Ο„) n T.unop)
  map f := GrpCat.ofHom {
    toFun x Ο„ := BlocksProjectors.blockPullback A ρ (j.localCharacter iota Ο„) n f.unop (x Ο„)
    map_one' := funext (fun Ο„ => (BlocksProjectors.blockPullback A ρ (j.localCharacter iota Ο„) n f.unop).map_one)
    map_mul' x y := funext (fun Ο„ =>
      (BlocksProjectors.blockPullback A ρ (j.localCharacter iota Ο„) n f.unop).map_mul (x Ο„) (y Ο„)) }
  map_id T := by
    apply GrpCat.hom_ext
    apply MonoidHom.ext
    intro x
    funext Ο„
    exact Subtype.ext (Category.id_comp (x Ο„).val)
  map_comp f h := by
    apply GrpCat.hom_ext
    apply MonoidHom.ext
    intro x
    funext Ο„
    exact Subtype.ext (Category.assoc _ _ (x Ο„).val)

/-- The product decomposition is natural on the entire big test category. -/
def torsionBlockIso (n : β„•) :
    A.torsionFunctor (q ^ n) β‰… productBlockFunctor j iota A ρ n :=
  NatIso.ofComponents (fun T => (torsionBlockEquiv j iota hsplit A ρ n T.unop).toGrpIso) (by
    intro T U f
    apply GrpCat.hom_ext
    apply MonoidHom.ext
    intro x
    funext Ο„
    exact Subtype.ext (Category.assoc _ _ _))

end

end OAI.AlgebraicGeometry.PELModuli.CMPoints.BlockDecomposition