File size: 7,686 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
import OAI.AlgebraicGeometry.PELModuli.IntegralModel.Cartesian.FamilyMorphismComparison
import Mathlib.AlgebraicGeometry.Sites.Fpqc

/-! # Group Pair -/

namespace OAI.AlgebraicGeometry.PELModuli.IntegralModel.Cartesian.GroupPair

noncomputable section

section

/-! Identify the cover of the quotient's relative square with the
product comparison induced by its actual cartesian family isomorphism. -/

set_option backward.isDefEq.respectTransparency false
set_option backward.isDefEq.respectTransparency.types false
open _root_.CategoryTheory _root_.CategoryTheory.Limits _root_.AlgebraicGeometry
open _root_.CategoryTheory.MonoidalCategory _root_.CategoryTheory.CartesianMonoidalCategory

theorem cartesian_group_pair_comparison {B T : Scheme.{0}} (u : T ⟶ B)
    (G : Over T) (A : Over B) (e : G ≅ (Over.pullback u).obj A)
    (q : G.left ⟶ A.left) (he : e.hom.left ≫ pullback.fst A.hom u = q)
    (qp : (G ⊗ G).left ⟶ (A ⊗ A).left)
    (h₁ : qp ≫ (fst A A).left = (fst G G).left ≫ q)
    (h₂ : qp ≫ (snd A A).left = (snd G G).left ≫ q) :
    (Functor.OplaxMonoidal.δ (Over.pullback u) A A ≫ (e.inv ⊗ₘ e.inv)).left ≫ qp =
      pullback.fst (A ⊗ A).hom u := by
  let F := Over.pullback u
  let l := Functor.OplaxMonoidal.δ F A A ≫ (e.inv ⊗ₘ e.inv)
  have hi : e.inv.left ≫ q = pullback.fst A.hom u := by
    rw [← he, ← Category.assoc, ← Over.comp_left, e.inv_hom_id, Over.id_left, Category.id_comp]
  have hl₁ : l.left ≫ (fst G G).left = (F.map (fst A A)).left ≫ e.inv.left := by
    change (l ≫ fst G G).left = (F.map (fst A A) ≫ e.inv).left
    apply congrArg Over.Hom.left
    change (Functor.OplaxMonoidal.δ F A A ≫ (e.inv ⊗ₘ e.inv)) ≫ fst G G = _
    rw [Category.assoc, tensorHom_fst, ← Category.assoc, Functor.OplaxMonoidal.δ_fst]
  have hl₂ : l.left ≫ (snd G G).left = (F.map (snd A A)).left ≫ e.inv.left := by
    change (l ≫ snd G G).left = (F.map (snd A A) ≫ e.inv).left
    apply congrArg Over.Hom.left
    change (Functor.OplaxMonoidal.δ F A A ≫ (e.inv ⊗ₘ e.inv)) ≫ snd G G = _
    rw [Category.assoc, tensorHom_snd, ← Category.assoc, Functor.OplaxMonoidal.δ_snd]
  change qp ≫ pullback.fst A.hom A.hom = (fst G G).left ≫ q at h₁
  change qp ≫ pullback.snd A.hom A.hom = (snd G G).left ≫ q at h₂
  apply pullback.hom_ext
  · change (l.left ≫ qp) ≫ pullback.fst A.hom A.hom = _
    rw [Category.assoc, h₁, ← Category.assoc, hl₁, Category.assoc, hi]
    exact FamilyMorphismComparison.over_pullback_map_fst u (fst A A)
  · change (l.left ≫ qp) ≫ pullback.snd A.hom A.hom = _
    rw [Category.assoc, h₂, ← Category.assoc, hl₂, Category.assoc, hi]
    exact FamilyMorphismComparison.over_pullback_map_fst u (snd A A)

end

section

/-! Identify multiplication after pullback with the actual covering
group family's multiplication. -/

set_option backward.isDefEq.respectTransparency false
set_option backward.isDefEq.respectTransparency.types false
open _root_.CategoryTheory _root_.CategoryTheory.Limits _root_.AlgebraicGeometry
open _root_.CategoryTheory.MonoidalCategory _root_.CategoryTheory.CartesianMonoidalCategory
open scoped _root_.CategoryTheory.MonObj _root_.CategoryTheory.Obj

theorem cartesian_group_multiplication_image {B T : Scheme.{0}} (u : T ⟶ B)
    (G : Over T) [GrpObj G] (A : Over B) (e : G ≅ (Over.pullback u).obj A)
    (q : G.left ⟶ A.left) (he : e.hom.left ≫ pullback.fst A.hom u = q)
    (qp : (G ⊗ G).left ⟶ (A ⊗ A).left)
    (h₁ : qp ≫ (fst A A).left = (fst G G).left ≫ q)
    (h₂ : qp ≫ (snd A A).left = (snd G G).left ≫ q)
    (m : A ⊗ A ⟶ A) (hm : qp ≫ m.left = (MonObj.mul : G ⊗ G ⟶ G).left ≫ q) :
    letI : GrpObj ((Over.pullback u).obj A) := GrpObj.ofIso e
    (Over.pullback u).map m = Functor.OplaxMonoidal.δ (Over.pullback u) A A ≫
      (MonObj.mul : (Over.pullback u).obj A ⊗ (Over.pullback u).obj A ⟶ (Over.pullback u).obj A) := by
  let : GrpObj ((Over.pullback u).obj A) := GrpObj.ofIso e
  let F := Over.pullback u
  let l := Functor.OplaxMonoidal.δ F A A ≫ (e.inv ⊗ₘ e.inv)
  have hl : l.left ≫ qp = pullback.fst (A ⊗ A).hom u :=
    cartesian_group_pair_comparison u G A e q he qp h₁ h₂
  apply Over.OverMorphism.ext
  apply pullback.hom_ext
  · change (F.map m).left ≫ pullback.fst A.hom u =
      ((Functor.OplaxMonoidal.δ F A A).left ≫
        (((e.inv ⊗ₘ e.inv).left ≫ (MonObj.mul : G ⊗ G ⟶ G).left) ≫ e.hom.left)) ≫
          pullback.fst A.hom u
    rw [FamilyMorphismComparison.over_pullback_map_fst, Category.assoc, Category.assoc, he]
    change _ = l.left ≫ ((MonObj.mul : G ⊗ G ⟶ G).left ≫ q)
    rw [← hm, ← Category.assoc, hl]
  · exact (F.map m).w.trans
      (Functor.OplaxMonoidal.δ F A A ≫
        (MonObj.mul : F.obj A ⊗ F.obj A ⟶ F.obj A)).w.symm

end

/-! All commutative group laws descend from the constructed operations
and their actual cartesian covering-family equations. -/

set_option backward.isDefEq.respectTransparency false
set_option backward.isDefEq.respectTransparency.types false
open _root_.CategoryTheory _root_.CategoryTheory.Limits _root_.AlgebraicGeometry
open _root_.CategoryTheory.MonoidalCategory _root_.CategoryTheory.CartesianMonoidalCategory
open scoped _root_.CategoryTheory.MonObj _root_.CategoryTheory.Obj

theorem commutative_group_descends_from_cartesian_operations {B T : Scheme.{0}}
    (u : T ⟶ B) [Flat u] [Surjective u] [LocallyOfFinitePresentation u]
    (G : Over T) [GrpObj G] [IsCommMonObj G] (A : Over B)
    (e : G ≅ (Over.pullback u).obj A)
    (q : G.left ⟶ A.left) (he : e.hom.left ≫ pullback.fst A.hom u = q)
    (qp : (G ⊗ G).left ⟶ (A ⊗ A).left)
    (h₁ : qp ≫ (fst A A).left = (fst G G).left ≫ q)
    (h₂ : qp ≫ (snd A A).left = (snd G G).left ≫ q)
    (z : 𝟙_ (Over B) ⟶ A) (m : A ⊗ A ⟶ A) (d : A ⟶ A)
    (hz : u ≫ z.left = (MonObj.one : 𝟙_ (Over T) ⟶ G).left ≫ q)
    (hm : qp ≫ m.left = (MonObj.mul : G ⊗ G ⟶ G).left ≫ q)
    (hd : q ≫ d.left = (GrpObj.inv : G ⟶ G).left ≫ q) :
    ∃ gA : GrpObj A, (letI := gA; IsCommMonObj A) ∧
      (letI := gA; IsMonHom e.hom) := by
  let F := Over.pullback u
  let : GrpObj (F.obj A) := GrpObj.ofIso e
  have : IsCommMonObj (F.obj A) := ArithmeticGeometry.Models.SpreadingOut.GroupReflection.Construction.commutative_group_of_iso e
  have hOne := FamilyMorphismComparison.cartesian_group_one_image u G A e q he z hz
  have hMul := cartesian_group_multiplication_image u G A e q he qp h₁ h₂ m hm
  have hInv := FamilyMorphismComparison.cartesian_group_inverse_image u G A e q he d hd
  let gA := ArithmeticGeometry.Models.SpreadingOut.GroupReflection.Construction.groupObjectOfMappedOperations F A z m d hOne hMul hInv
    F.map_injective F.map_injective F.map_injective F.map_injective
  have himage := ArithmeticGeometry.Models.SpreadingOut.GroupReflection.Construction.groupObjectOfMappedOperations_image F A z m d hOne hMul hInv
    F.map_injective F.map_injective F.map_injective F.map_injective
  refine ⟨gA, ArithmeticGeometry.Models.SpreadingOut.GroupReflection.Construction.groupObjectOfMappedOperations_comm F A z m d hOne hMul hInv
    F.map_injective F.map_injective F.map_injective F.map_injective F.map_injective, ?_⟩
  let := gA
  let : GrpObj (F.obj A) := Functor.grpObjObj (F := F) (G := A)
  have hi : IsMonHom e.inv := ArithmeticGeometry.Models.SpreadingOut.GroupReflection.Construction.image_group_iso_isMonHom F A G e.symm gA himage
  have : IsMonHom e.symm.hom := hi
  exact inferInstanceAs (IsMonHom e.symm.inv)

end

end OAI.AlgebraicGeometry.PELModuli.IntegralModel.Cartesian.GroupPair