File size: 6,241 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
import OAI.AlgebraicGeometry.PELModuli.CMPoints.BlockDecomposition
import OAI.AlgebraicGeometry.PELModuli.CMPoints.BlockSchemeTower
import OAI.AlgebraicGeometry.AbelianModuli.HilbertConstruction.TorsionScheme

/-! # Block Retraction -/

namespace OAI.AlgebraicGeometry.PELModuli.CMPoints.BlockRetraction

noncomputable section

/-! Each coefficient block is an actual scheme retract of the full
torsion scheme, via its integral projector. -/

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

theorem iso_conjugated_retraction
    {C : Type*} [Category C] {X Y B G : C}
    (eB : X β‰… B) (eG : Y β‰… G) (i : B ⟢ G) (r : G ⟢ B) (h : i ≫ r = πŸ™ B) :
    (eB.hom ≫ i ≫ eG.inv) ≫ (eG.hom ≫ r ≫ eB.inv) = πŸ™ X := by
  simp only [Category.assoc, Iso.inv_hom_id_assoc]
  rw [← Category.assoc i r, h, Category.id_comp, Iso.hom_inv_id]

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)

def torsionProjectionNat (n : β„•) (Ο„ : Gal(E/β„š)) :
    A.torsionFunctor (q ^ n) ⟢ BlocksProjectors.blockFunctor A ρ (j.localCharacter iota Ο„) n where
  app T := GrpCat.ofHom (BlockDecomposition.torsionProjection j iota hsplit A ρ n Ο„ T.unop)
  naturality _ _ _ := by
    apply GrpCat.hom_ext
    apply MonoidHom.ext
    intro x
    exact Subtype.ext (Category.assoc _ _ _)

theorem blockInclusion_projection (n : β„•) (Ο„ : Gal(E/β„š)) :
    BlocksProjectors.blockInclusion A ρ (j.localCharacter iota Ο„) n ≫ torsionProjectionNat j iota hsplit A ρ n Ο„ =
      πŸ™ (BlocksProjectors.blockFunctor A ρ (j.localCharacter iota Ο„) n) := by
  apply NatTrans.ext
  funext T
  apply GrpCat.hom_ext
  apply MonoidHom.ext
  intro x
  exact Subtype.ext (BlockDecomposition.block_projector_self j iota hsplit A ρ n Ο„ T.unop x)

abbrev actualTorsionGroup (n : β„•) : Grp (Over S) := ⟨A.torsionScheme (q ^ n)⟩

def blockToTorsionGroup (n : β„•) (Ο„ : Gal(E/β„š)) :
    (BlocksProjectors.splitBlockGroupScheme j iota hsplit A ρ n Ο„).toGrp ⟢ actualTorsionGroup (q := q) A n :=
  yonedaGrpFullyFaithful.preimage
    ((BlockSchemeTower.blockYonedaIso j iota hsplit A ρ n Ο„).hom ≫
      BlocksProjectors.blockInclusion A ρ (j.localCharacter iota Ο„) n ≫ (A.torsionSchemeYonedaIso (q ^ n)).inv)

def torsionToBlockGroup (n : β„•) (Ο„ : Gal(E/β„š)) :
    actualTorsionGroup (q := q) A n ⟢ (BlocksProjectors.splitBlockGroupScheme j iota hsplit A ρ n Ο„).toGrp :=
  yonedaGrpFullyFaithful.preimage
    ((A.torsionSchemeYonedaIso (q ^ n)).hom ≫ torsionProjectionNat j iota hsplit A ρ n Ο„ ≫
      (BlockSchemeTower.blockYonedaIso j iota hsplit A ρ n Ο„).inv)

theorem block_group_retraction (n : β„•) (Ο„ : Gal(E/β„š)) :
    blockToTorsionGroup j iota hsplit A ρ n Ο„ ≫ torsionToBlockGroup j iota hsplit A ρ n Ο„ = πŸ™ _ := by
  apply yonedaGrp.map_injective
  rw [CategoryTheory.Functor.map_comp, CategoryTheory.Functor.map_id]
  dsimp only [blockToTorsionGroup, torsionToBlockGroup]
  rw [yonedaGrpFullyFaithful.map_preimage, yonedaGrpFullyFaithful.map_preimage]
  exact iso_conjugated_retraction (BlockSchemeTower.blockYonedaIso j iota hsplit A ρ n Ο„)
    (A.torsionSchemeYonedaIso (q ^ n)) _ _ (blockInclusion_projection j iota hsplit A ρ n Ο„)

theorem block_scheme_retraction (n : β„•) (Ο„ : Gal(E/β„š)) :
    (blockToTorsionGroup j iota hsplit A ρ n Ο„).hom.hom ≫
      (torsionToBlockGroup j iota hsplit A ρ n Ο„).hom.hom = πŸ™ _ :=
  congrArg (fun f => (Grp.forget (Over S)).map f) (block_group_retraction j iota hsplit A ρ n Ο„)

theorem blockToTorsionGroup_inclusion (n : β„•) (Ο„ : Gal(E/β„š)) :
    (blockToTorsionGroup j iota hsplit A ρ n Ο„).hom.hom ≫ A.torsionInclusion (q ^ n) =
      BlockSchemeTower.blockSchemeInclusion j iota hsplit A ρ n Ο„ := by
  have h := yonedaGrpFullyFaithful.map_preimage
    (X := (BlocksProjectors.splitBlockGroupScheme j iota hsplit A ρ n Ο„).toGrp)
    (Y := actualTorsionGroup (q := q) A n)
    ((BlockSchemeTower.blockYonedaIso j iota hsplit A ρ n Ο„).hom ≫
      BlocksProjectors.blockInclusion A ρ (j.localCharacter iota Ο„) n ≫ (A.torsionSchemeYonedaIso (q ^ n)).inv)
  have hcancel :
      ((BlockSchemeTower.blockYonedaIso j iota hsplit A ρ n Ο„).hom ≫
        BlocksProjectors.blockInclusion A ρ (j.localCharacter iota Ο„) n ≫ (A.torsionSchemeYonedaIso (q ^ n)).inv) ≫
          (A.torsionSchemeYonedaIso (q ^ n)).hom =
        (BlockSchemeTower.blockYonedaIso j iota hsplit A ρ n Ο„).hom ≫ BlocksProjectors.blockInclusion A ρ (j.localCharacter iota Ο„) n := by
    simp only [Category.assoc, Iso.inv_hom_id, Category.comp_id]
  have hc := (congrArg (fun Ξ± => Ξ± ≫ (A.torsionSchemeYonedaIso (q ^ n)).hom) h).trans hcancel
  have hx := congrArg (fun Ξ± =>
    ((Ξ±.app (op (BlocksProjectors.splitBlockGroupScheme j iota hsplit A ρ n Ο„).X)).hom (πŸ™ _)).val) hc
  change ((πŸ™ _) ≫ (blockToTorsionGroup j iota hsplit A ρ n Ο„).hom.hom) ≫
    A.torsionInclusion (q ^ n) = (πŸ™ _) ≫ BlockSchemeTower.blockSchemeInclusion j iota hsplit A ρ n Ο„ at hx
  simpa only [Category.id_comp] using hx

instance blockToTorsionGroup_closed (n : β„•) (Ο„ : Gal(E/β„š)) :
    IsClosedImmersion (blockToTorsionGroup j iota hsplit A ρ n Ο„).hom.hom.left := by
  let : IsClosedImmersion (A.torsionInclusion (q ^ n)).left :=
    AbelianModuli.HilbertConstruction.Abelian.Schemes.AbelianScheme.torsionInclusion_closedImmersion A (q ^ n)
  have h := congrArg Over.Hom.left (blockToTorsionGroup_inclusion j iota hsplit A ρ n Ο„)
  have : IsClosedImmersion
      ((blockToTorsionGroup j iota hsplit A ρ n Ο„).hom.hom.left ≫ (A.torsionInclusion (q ^ n)).left) :=
    (congrArg IsClosedImmersion h).mpr (BlocksProjectors.idempotentBlockInclusion_closed A ρ _ _)
  exact IsClosedImmersion.of_comp _ (A.torsionInclusion (q ^ n)).left

end

end OAI.AlgebraicGeometry.PELModuli.CMPoints.BlockRetraction