File size: 4,966 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
import OAI.AlgebraicGeometry.PELModuli.CMPoints.BlocksProjectors
import OAI.AlgebraicGeometry.PELModuli.CMPoints.BlockTower

/-! # Block Scheme Tower -/

namespace OAI.AlgebraicGeometry.PELModuli.CMPoints.BlockSchemeTower

noncomputable section

/-! The ascending character-block functors are represented by closed
embeddings of the actual block schemes. The Yoneda construction follows
the generic checked bridge in TorsionLevels, placed here without
the later node's Cartier and ordinary-block dependencies. -/

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

variable {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)
  {S : Scheme} {g : β„•} (A : AbelianModuli.HilbertConstruction.Abelian.Schemes.AbelianScheme g S)
  (ρ : AbelianModuli.ReferenceFamily.ActionData.IntegralAction (NumberField.RingOfIntegers E) A)

def blockYonedaIso (n : β„•) (Ο„ : Gal(E/β„š)) :
    yonedaGrp.obj (BlocksProjectors.splitBlockGroupScheme j iota hsplit A ρ n Ο„).toGrp β‰…
      BlocksProjectors.blockFunctor A ρ (j.localCharacter iota Ο„) n :=
  yonedaGrpObjIsoOfRepresentableBy
    (BlocksProjectors.idempotentBlockScheme A ρ (q ^ n) (j.projector iota hsplit n Ο„))
    (BlocksProjectors.blockFunctor A ρ (j.localCharacter iota Ο„) n)
    (BlocksProjectors.splitBlockRepresentable j iota hsplit A ρ n Ο„)

abbrev blockSchemeInclusion (n : β„•) (Ο„ : Gal(E/β„š)) :
    (BlocksProjectors.splitBlockGroupScheme j iota hsplit A ρ n Ο„).X ⟢ A.scheme :=
  BlocksProjectors.idempotentBlockInclusion A ρ (q ^ n) (j.projector iota hsplit n Ο„)

theorem blockSchemeInclusion_point (n : β„•) (Ο„ : Gal(E/β„š)) (T : Over S)
    (x : T ⟢ (BlocksProjectors.splitBlockGroupScheme j iota hsplit A ρ n Ο„).X) :
    ((blockYonedaIso j iota hsplit A ρ n Ο„).hom.app (op T) x).val =
      x ≫ blockSchemeInclusion j iota hsplit A ρ n Ο„ := rfl

def blockSchemeLevelEmbedding (Ο„ : Gal(E/β„š)) {n m : β„•} (hnm : n ≀ m) :
    (BlocksProjectors.splitBlockGroupScheme j iota hsplit A ρ n Ο„).toGrp ⟢
      (BlocksProjectors.splitBlockGroupScheme j iota hsplit A ρ m Ο„).toGrp :=
  (yonedaGrpFullyFaithful (C := Over S)).preimage
    ((blockYonedaIso j iota hsplit A ρ n Ο„).hom ≫
      BlockTower.blockInclusionNat A ρ (j.localCharacter iota Ο„) n m hnm ≫
        (blockYonedaIso j iota hsplit A ρ m Ο„).inv)

theorem blockSchemeLevelEmbedding_points (Ο„ : Gal(E/β„š)) {n m : β„•} (hnm : n ≀ m)
    (T : Over S) (x : T ⟢ (BlocksProjectors.splitBlockGroupScheme j iota hsplit A ρ n Ο„).X) :
    (blockYonedaIso j iota hsplit A ρ m Ο„).hom.app (op T)
      (x ≫ (blockSchemeLevelEmbedding j iota hsplit A ρ Ο„ hnm).hom.hom) =
        (BlockTower.blockInclusionNat A ρ (j.localCharacter iota Ο„) n m hnm).app (op T)
          ((blockYonedaIso j iota hsplit A ρ n Ο„).hom.app (op T) x) := by
  have h := (yonedaGrpFullyFaithful (C := Over S)).map_preimage
    ((blockYonedaIso j iota hsplit A ρ n Ο„).hom ≫
      BlockTower.blockInclusionNat A ρ (j.localCharacter iota Ο„) n m hnm ≫
        (blockYonedaIso j iota hsplit A ρ m Ο„).inv)
  have hc := congrArg (fun Ξ± => Ξ± ≫ (blockYonedaIso j iota hsplit A ρ m Ο„).hom) h
  simp only [Category.assoc, Iso.inv_hom_id, Category.comp_id] at hc
  exact congrArg (fun Ξ± => (Ξ±.app (op T)).hom x) hc

theorem blockSchemeLevelEmbedding_inclusion (Ο„ : Gal(E/β„š)) {n m : β„•} (hnm : n ≀ m) :
    (blockSchemeLevelEmbedding j iota hsplit A ρ Ο„ hnm).hom.hom ≫
      blockSchemeInclusion j iota hsplit A ρ m Ο„ = blockSchemeInclusion j iota hsplit A ρ n Ο„ := by
  have h := congrArg Subtype.val
    (blockSchemeLevelEmbedding_points j iota hsplit A ρ Ο„ hnm _ (πŸ™ _))
  change ((πŸ™ _) ≫ (blockSchemeLevelEmbedding j iota hsplit A ρ Ο„ hnm).hom.hom) ≫
    blockSchemeInclusion j iota hsplit A ρ m Ο„ =
      (πŸ™ _) ≫ blockSchemeInclusion j iota hsplit A ρ n Ο„ at h
  simpa only [Category.id_comp] using h

instance blockSchemeLevelEmbedding_closed (Ο„ : Gal(E/β„š)) {n m : β„•} (hnm : n ≀ m) :
    IsClosedImmersion (blockSchemeLevelEmbedding j iota hsplit A ρ Ο„ hnm).hom.hom.left := by
  have : IsClosedImmersion (blockSchemeInclusion j iota hsplit A ρ m Ο„).left :=
    BlocksProjectors.idempotentBlockInclusion_closed A ρ _ _
  have h := congrArg Over.Hom.left
    (blockSchemeLevelEmbedding_inclusion j iota hsplit A ρ Ο„ hnm)
  have : IsClosedImmersion
      ((blockSchemeLevelEmbedding j iota hsplit A ρ Ο„ hnm).hom.hom.left ≫
        (blockSchemeInclusion j iota hsplit A ρ m Ο„).left) :=
    (congrArg IsClosedImmersion h).mpr (BlocksProjectors.idempotentBlockInclusion_closed A ρ _ _)
  exact IsClosedImmersion.of_comp _ (blockSchemeInclusion j iota hsplit A ρ m Ο„).left

end

end OAI.AlgebraicGeometry.PELModuli.CMPoints.BlockSchemeTower