math / data /lean /OAI /AlgebraicGeometry /PELModuli /CMPoints /BlockDecomposition.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
8.49 kB
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