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
|