File size: 7,043 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
import OAI.AlgebraicGeometry.PELModuli.IntegralModel.Open.BaseActionGluing
import Mathlib.AlgebraicGeometry.Properties

/-! # Action Matching Compatibility -/

namespace OAI.AlgebraicGeometry.PELModuli.IntegralModel.Open.ActionMatchingCompatibility

noncomputable section

section

/-! Evaluation at the tautological point of a source overlap. This turns
equal restricted actions into equal actual morphisms on that overlap. -/

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

namespace OpenActionOverlap
variable {S : Scheme.{0}} (C : S.OpenCover) {g : ℕ} (A : AbelianModuli.HilbertConstruction.Abelian.Schemes.AbelianScheme g S) (i j : C.I₀)

def source : Scheme := pullback (pullback.fst A.scheme.hom (C.f i))
  (pullback.fst A.scheme.hom (C.f j))

def sourceLeft : source C A i j ⟶ pullback A.scheme.hom (C.f i) := pullback.fst _ _
def sourceRight : source C A i j ⟶ pullback A.scheme.hom (C.f j) := pullback.snd _ _

def test : Over S := Over.mk
  ((sourceLeft C A i j ≫ pullback.fst A.scheme.hom (C.f i)) ≫ A.scheme.hom)

instance test_reduced [IsReduced A.scheme.left] : IsReduced (test C A i j).left := by
  have : IsReduced (pullback A.scheme.hom (C.f i)) :=
    isReduced_of_isOpenImmersion (pullback.fst A.scheme.hom (C.f i))
  exact isReduced_of_isOpenImmersion (pullback.fst
    (pullback.fst A.scheme.hom (C.f i)) (pullback.fst A.scheme.hom (C.f j)))

def testLeft : test C A i j ⟶ Over.mk (C.f i) := Over.homMk
  (sourceLeft C A i j ≫ pullback.snd A.scheme.hom (C.f i)) (by
    change (_ ≫ pullback.snd A.scheme.hom (C.f i)) ≫ C.f i = _
    rw [Category.assoc, ← pullback.condition, ← Category.assoc]
    rfl)

def testRight : test C A i j ⟶ Over.mk (C.f j) := Over.homMk
  (sourceRight C A i j ≫ pullback.snd A.scheme.hom (C.f j)) (by
    change (_ ≫ pullback.snd A.scheme.hom (C.f j)) ≫ C.f j = _
    rw [Category.assoc, ← pullback.condition, ← Category.assoc]
    exact congrArg (fun q => q ≫ A.scheme.hom) (pullback.condition
      (f := pullback.fst A.scheme.hom (C.f i)) (g := pullback.fst A.scheme.hom (C.f j))).symm)

def evaluation : source C A i j ⟶ pullback A.scheme.hom (test C A i j).hom :=
  pullback.lift (sourceLeft C A i j ≫ pullback.fst A.scheme.hom (C.f i))
    (𝟙 _) (Category.id_comp _).symm

theorem evaluation_snd : evaluation C A i j ≫ pullback.snd A.scheme.hom (test C A i j).hom =
    𝟙 (source C A i j) := pullback.lift_snd _ _ _

theorem evaluation_left : evaluation C A i j ≫ EndomorphismFamiliesId.EndomorphismFamilies.familyMap A (testLeft C A i j) =
    sourceLeft C A i j := by
  apply pullback.hom_ext
  · rw [Category.assoc, EndomorphismFamiliesId.EndomorphismFamilies.familyMap_fst]
    exact pullback.lift_fst _ _ _
  · rw [Category.assoc, EndomorphismFamiliesId.EndomorphismFamilies.familyMap_snd, ← Category.assoc]
    rw [evaluation_snd, Category.id_comp]
    rfl

theorem evaluation_right : evaluation C A i j ≫ EndomorphismFamiliesId.EndomorphismFamilies.familyMap A (testRight C A i j) =
    sourceRight C A i j := by
  apply pullback.hom_ext
  · rw [Category.assoc, EndomorphismFamiliesId.EndomorphismFamilies.familyMap_fst]
    exact (pullback.lift_fst _ _ _).trans (pullback.condition
      (f := pullback.fst A.scheme.hom (C.f i)) (g := pullback.fst A.scheme.hom (C.f j)))
  · rw [Category.assoc, EndomorphismFamiliesId.EndomorphismFamilies.familyMap_snd, ← Category.assoc]
    rw [evaluation_snd, Category.id_comp]
    rfl

theorem endomorphism_equality (ri : Finite.Actions.GroupEndRing (A.pullback (C.f i)))
    (rj : Finite.Actions.GroupEndRing (A.pullback (C.f j)))
    (h : EndomorphismFamiliesId.EndomorphismFamilies.restrict A (testLeft C A i j) ri = EndomorphismFamiliesId.EndomorphismFamilies.restrict A (testRight C A i j) rj) :
    sourceLeft C A i j ≫ EndomorphismFamiliesId.EndomorphismFamilies.endHom A (T := Over.mk (C.f i)) ri ≫ pullback.fst A.scheme.hom (C.f i) =
      sourceRight C A i j ≫ EndomorphismFamiliesId.EndomorphismFamilies.endHom A (T := Over.mk (C.f j)) rj ≫ pullback.fst A.scheme.hom (C.f j) := by
  have he : EndomorphismFamiliesId.EndomorphismFamilies.familyMap A (testLeft C A i j) ≫ EndomorphismFamiliesId.EndomorphismFamilies.endHom A (T := Over.mk (C.f i)) ri ≫ pullback.fst A.scheme.hom (C.f i) =
      EndomorphismFamiliesId.EndomorphismFamilies.familyMap A (testRight C A i j) ≫ EndomorphismFamiliesId.EndomorphismFamilies.endHom A (T := Over.mk (C.f j)) rj ≫ pullback.fst A.scheme.hom (C.f j) :=
    (EndomorphismFamiliesId.EndomorphismFamilies.restrict_fst A (testLeft C A i j) ri).symm.trans
      ((congrArg (fun r => EndomorphismFamiliesId.EndomorphismFamilies.endHom A r ≫ pullback.fst A.scheme.hom (test C A i j).hom) h).trans
        (EndomorphismFamiliesId.EndomorphismFamilies.restrict_fst A (testRight C A i j) rj))
  have he' := congrArg (fun q => evaluation C A i j ≫ q) he
  simpa only [← Category.assoc, evaluation_left, evaluation_right] using he'

end OpenActionOverlap

end

/-! Matching actual action-functor values imply the literal source-overlap
equations needed for effective gluing. -/

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

variable {S : Scheme.{0}} (C : S.OpenCover) {g : ℕ} (A : AbelianModuli.HilbertConstruction.Abelian.Schemes.AbelianScheme g S)
    [IsReduced A.scheme.left] {R : Type} [CommRing R]
    (ρ : ∀ i, AbelianModuli.ReferenceFamily.ActionData.IntegralAction R (A.pullback (C.f i)))
    (hmatch : ∀ i j (T : Over S) [IsReduced T.left]
      (f : T ⟶ Over.mk (C.f i)) (h : T ⟶ Over.mk (C.f j)),
      Integral.ActionScheme.restrictIntegralAction A (ρ i) f = Integral.ActionScheme.restrictIntegralAction A (ρ j) h)

include hmatch in
theorem openAction_matching_compatible (a : R) :
    BaseGroupReflection.OpenBaseMorphismCompatible C (fun i => (ρ i).map a) := by
  intro i j
  let T := OpenActionOverlap.test C A i j
  let f := OpenActionOverlap.testLeft C A i j
  let h := OpenActionOverlap.testRight C A i j
  have he := congrArg
    (fun σ : AbelianModuli.ReferenceFamily.ActionData.IntegralAction R (A.pullback T.hom) => Finite.Actions.ringHomOfIntegralAction _ σ a)
    (hmatch i j T f h)
  exact OpenActionOverlap.endomorphism_equality C A i j
    (Finite.Actions.ringHomOfIntegralAction (A.pullback (C.f i)) (ρ i) a)
    (Finite.Actions.ringHomOfIntegralAction (A.pullback (C.f j)) (ρ j) a) he

include hmatch in
theorem existsUnique_action_of_reduced_matching :
    ∃! σ : AbelianModuli.ReferenceFamily.ActionData.IntegralAction R A, ∀ i, σ.pullback (C.f i) = ρ i :=
  BaseActionGluing.existsUnique_integralAction_of_open_base_cover C A ρ (openAction_matching_compatible C A ρ hmatch)

end

end OAI.AlgebraicGeometry.PELModuli.IntegralModel.Open.ActionMatchingCompatibility