File size: 12,286 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
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
import OAI.AlgebraicGeometry.PELModuli.IntegralModel.Reduced.OpenRepresentationLifts
import Mathlib.AlgebraicGeometry.Gluing
import Mathlib.AlgebraicGeometry.Limits
import Mathlib.CategoryTheory.Limits.Constructions.Over.Basic

/-! # Representation Atlas -/

namespace OAI

noncomputable section

namespace AlgebraicGeometry.PELModuli.IntegralModel.Reduced

/-! The triple-overlap maps of reduced local representations, with their
cocycle identity proved by the actual universal values. -/

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

variable {S : Scheme.{0}} {F : (Over S)ᵒᵖ ⥤ Type} {U V W : S.Opens}
    (D : OpenRepresentations.ReducedOpenRepresentation F U) (E : OpenRepresentations.ReducedOpenRepresentation F V)
    (G : OpenRepresentations.ReducedOpenRepresentation F W)

def OpenRepresentations.ReducedOpenRepresentation.tripleLift {T : Over S} (f : T ⟶ D.overlap E) (g : T ⟶ D.overlap G) :
    T ⟶ E.overlap G :=
  E.overlapLift G (f ≫ D.comparison E ≫ E.inclusion D) (fun t => by
    have h := D.overlap_mapsTo_right G (g.left t)
    exact (congrArg (fun q : T.left ⟶ S => q t) g.w) ▸ h)

@[reassoc]
theorem OpenRepresentations.ReducedOpenRepresentation.tripleLift_inclusion {T : Over S} (f : T ⟶ D.overlap E) (g : T ⟶ D.overlap G) :
    D.tripleLift E G f g ≫ E.inclusion G = f ≫ D.comparison E ≫ E.inclusion D :=
  E.overlapLift_inclusion G _ _

def OpenRepresentations.ReducedOpenRepresentation.tripleMap : pullback (D.inclusion E) (D.inclusion G) ⟶
    pullback (E.inclusion G) (E.inclusion D) :=
  pullback.lift (D.tripleLift E G (pullback.fst _ _) (pullback.snd _ _))
    (pullback.fst _ _ ≫ D.comparison E) (by
      rw [OpenRepresentations.ReducedOpenRepresentation.tripleLift_inclusion, Category.assoc])

@[reassoc]
theorem OpenRepresentations.ReducedOpenRepresentation.tripleMap_snd : D.tripleMap E G ≫ pullback.snd _ _ =
    pullback.fst _ _ ≫ D.comparison E := pullback.lift_snd _ _ _

@[reassoc]
theorem OpenRepresentations.ReducedOpenRepresentation.tripleMap_fst_inclusion : D.tripleMap E G ≫ pullback.fst _ _ ≫ E.inclusion G =
    pullback.fst _ _ ≫ D.comparison E ≫ E.inclusion D := by
  rw [← Category.assoc, OpenRepresentations.ReducedOpenRepresentation.tripleMap, pullback.lift_fst, OpenRepresentations.ReducedOpenRepresentation.tripleLift_inclusion]

theorem OpenRepresentations.ReducedOpenRepresentation.tripleMap_value {T : Over S}
    (f : T ⟶ pullback (D.inclusion E) (D.inclusion G)) :
    F.map (f ≫ D.tripleMap E G ≫ pullback.fst _ _ ≫ E.inclusion G).op E.sectionValue =
      F.map (f ≫ pullback.fst _ _ ≫ D.inclusion E).op D.sectionValue := by
  rw [OpenRepresentations.ReducedOpenRepresentation.tripleMap_fst_inclusion]
  simp only [op_comp, F.map_comp, types_comp_apply, OpenRepresentations.ReducedOpenRepresentation.comparison_value]

instance OpenRepresentations.ReducedOpenRepresentation.triple_reduced : IsReduced (pullback (D.inclusion E) (D.inclusion G)).left := by
  let p := pullback.fst (D.inclusion E) (D.inclusion G)
  have : IsOpenImmersion p.left := MorphismProperty.of_isPullback
    ((IsPullback.of_hasPullback (D.inclusion E) (D.inclusion G)).map (Over.forget S)).flip
    (D.inclusion_open G)
  exact isReduced_of_isOpenImmersion p.left

theorem OpenRepresentations.ReducedOpenRepresentation.tripleMap_cocycle :
    D.tripleMap E G ≫ E.tripleMap G D ≫ G.tripleMap D E = 𝟙 _ := by
  apply (cancel_mono (pullback.fst (D.inclusion E) (D.inclusion G))).mp
  apply (cancel_mono (D.inclusion E)).mp
  apply D.hom_ext
  simp only [Category.assoc, Category.id_comp]
  rw [← Category.assoc (D.tripleMap E G), OpenRepresentations.ReducedOpenRepresentation.tripleMap_value,
    Category.assoc, OpenRepresentations.ReducedOpenRepresentation.tripleMap_value]
  simpa only [Category.id_comp] using D.tripleMap_value E G (𝟙 _)

end AlgebraicGeometry.PELModuli.IntegralModel.Reduced

namespace AlgebraicGeometry.PELModuli.IntegralModel.Reduced.RepresentationAtlas
section

/-! The actual scheme atlas obtained from local representations on reduced
tests. The transition maps and cocycle are constructed, rather than inputs. -/

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

namespace ReducedRepresentationAtlas
variable {S : Scheme.{0}} {F : (Over S)ᵒᵖ ⥤ Type} {I : Type} {U : I → S.Opens}
    (D : ∀ i, OpenRepresentations.ReducedOpenRepresentation F (U i))

def glueDataOver : CategoryTheory.GlueData (Over S) where
  J := I
  U i := (D i).space
  V p := (D p.1).overlap (D p.2)
  f i j := (D i).inclusion (D j)
  t i j := (D i).comparison (D j)
  t_id i := (D i).comparison_self
  t' i j k := (D i).tripleMap (D j) (D k)
  t_fac i j k := (D i).tripleMap_snd (D j) (D k)
  cocycle i j k := (D i).tripleMap_cocycle (D j) (D k)

def glueData : Scheme.GlueData where
  toGlueData := (glueDataOver D).mapGlueData (Over.forget S)
  f_open i j := (D i).inclusion_open (D j)

def scheme : Scheme := (glueData D).glued

def chart (i : I) : (D i).space.left ⟶ scheme D := (glueData D).ι i

instance chart_open (i : I) : IsOpenImmersion (chart D i) :=
  Scheme.GlueData.ι_isOpenImmersion (glueData D) i

def structureMap : scheme D ⟶ S := by
  fapply Multicoequalizer.desc
  · exact fun i => (D i).space.hom
  rintro ⟨i, j⟩
  change ((D i).inclusion (D j)).left ≫ (D i).space.hom =
    (((D i).comparison (D j)).left ≫ ((D j).inclusion (D i)).left) ≫ (D j).space.hom
  rw [Category.assoc, ((D i).inclusion (D j)).w, ((D j).inclusion (D i)).w,
    ((D i).comparison (D j)).w]

@[reassoc]
theorem chart_structureMap (i : I) : chart D i ≫ structureMap D = (D i).space.hom :=
  Multicoequalizer.π_desc _ _ _ _ _

def over : Over S := Over.mk (structureMap D)

def chartOver (i : I) : (D i).space ⟶ over D :=
  Over.homMk (chart D i) (chart_structureMap D i)

theorem charts_cover (z : scheme D) : ∃ i, ∃ x : (D i).space.left, chart D i x = z :=
  (glueData D).ι_jointly_surjective z

def openCover : (scheme D).OpenCover := (glueData D).openCover

instance reduced : IsReduced (scheme D) := by
  have (i : I) : IsReduced ((ReducedRepresentationAtlas.openCover D).X i) := (D i).reduced
  exact IsReduced.of_openCover (scheme D) (𝒰 := ReducedRepresentationAtlas.openCover D)

theorem chart_intersection (i j : I) :
    IsPullback ((D i).inclusion (D j)).left
      (((D i).comparison (D j)).left ≫ ((D j).inclusion (D i)).left)
      (chart D i) (chart D j) :=
  IsPullback.of_isLimit ((glueData D).vPullbackConeIsLimit i j)

theorem chart_glue (i j : I) :
    ((D i).comparison (D j)).left ≫ ((D j).inclusion (D i)).left ≫ chart D j =
      ((D i).inclusion (D j)).left ≫ chart D i := (glueData D).glue_condition i j

end ReducedRepresentationAtlas

end

section

/-! Each glued parameter chart is the full inverse image of its base open. -/

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

namespace ReducedRepresentationAtlas
variable {S : Scheme.{0}} {F : (Over S)ᵒᵖ ⥤ Type} {I : Type} {U : I → S.Opens}
    (D : ∀ i, OpenRepresentations.ReducedOpenRepresentation F (U i))

theorem chart_range (i : I) : Set.range (chart D i) =
    (structureMap D) ⁻¹' (U i : Set S) := by
  ext z
  constructor
  · rintro ⟨x, rfl⟩
    change structureMap D (chart D i x) ∈ U i
    have h : structureMap D (chart D i x) = (D i).space.hom x :=
      congrArg (fun q : (D i).space.left ⟶ S => q x) (chart_structureMap D i)
    exact h ▸ (D i).mapsTo x
  · intro hz
    obtain ⟨j, x, rfl⟩ := charts_cover D z
    have hx : (D j).space.hom x ∈ U i := by
      have h : structureMap D (chart D j x) = (D j).space.hom x :=
        congrArg (fun q : (D j).space.left ⟶ S => q x) (chart_structureMap D j)
      exact h ▸ hz
    let y : ((D j).overlap (D i)).left := ⟨x, hx⟩
    refine ⟨((D i).inclusion (D j)).left (((D j).comparison (D i)).left y), ?_⟩
    exact congrArg (fun q : ((D j).overlap (D i)).left ⟶ scheme D => q y)
      (chart_glue D j i)

theorem chart_opensRange (i : I) : (chart D i).opensRange = structureMap D ⁻¹ᵁ U i :=
  TopologicalSpace.Opens.coe_inj.mp (chart_range D i)

def chartBase (i : I) : (D i).space.left ⟶ (U i).toScheme :=
  IsOpenImmersion.lift (U i).ι (D i).space.hom (by
    rw [Scheme.Opens.range_ι]
    rintro _ ⟨x, rfl⟩
    exact (D i).mapsTo x)

@[reassoc]
theorem chartBase_ι (i : I) : chartBase D i ≫ (U i).ι = (D i).space.hom :=
  IsOpenImmersion.lift_fac _ _ _

theorem chart_isPullback (i : I) :
    IsPullback (chartBase D i) (chart D i) (U i).ι (structureMap D) := by
  refine ⟨⟨by rw [chartBase_ι, chart_structureMap]⟩,
    ⟨PullbackCone.IsLimit.mk _ ?_ ?_ ?_ ?_⟩⟩
  · intro c
    apply IsOpenImmersion.lift (chart D i) c.snd
    rw [chart_range]
    rintro _ ⟨x, rfl⟩
    change structureMap D (c.snd x) ∈ U i
    have h : structureMap D (c.snd x) = (U i).ι (c.fst x) :=
      congrArg (fun q : c.pt ⟶ S => q x) c.condition.symm
    exact h ▸ (c.fst x).property
  · intro c
    rw [← cancel_mono (U i).ι, Category.assoc, chartBase_ι,
      ← chart_structureMap D i, IsOpenImmersion.lift_fac_assoc, c.condition]
  · intro c
    exact IsOpenImmersion.lift_fac _ _ _
  · intro c m _ h2
    apply (cancel_mono (chart D i)).mp
    rw [IsOpenImmersion.lift_fac]
    exact h2

end ReducedRepresentationAtlas

end

/-! Once a global universal value restricts to the local universal values,
its classifier is bijective on every reduced test contained in a base chart. -/

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

namespace ReducedRepresentationAtlas
variable {S : Scheme.{0}} {F : (Over S)ᵒᵖ ⥤ Type} {I : Type} {U : I → S.Opens}
    (D : ∀ i, OpenRepresentations.ReducedOpenRepresentation F (U i))

instance chartOver_mono (i : I) : Mono (chartOver D i) :=
  (Over.forget S).mono_of_mono_map (show Mono (chartOver D i).left from inferInstanceAs (Mono (chart D i)))

def factorToChart (i : I) {T : Over S} (hT : ∀ t : T.left, T.hom t ∈ U i)
    (f : T ⟶ over D) : T ⟶ (D i).space := by
  have hr : Set.range f.left ⊆ Set.range (chart D i) := by
    rw [chart_range]
    rintro _ ⟨t, rfl⟩
    change structureMap D (f.left t) ∈ U i
    have ht : structureMap D (f.left t) = T.hom t := congrArg (fun q : T.left ⟶ S => q t) f.w
    exact ht ▸ hT t
  let q := IsOpenImmersion.lift (chart D i) f.left hr
  refine Over.homMk q ?_
  rw [← chart_structureMap D i, IsOpenImmersion.lift_fac_assoc]
  exact f.w

theorem factorToChart_chart (i : I) {T : Over S} (hT : ∀ t : T.left, T.hom t ∈ U i)
    (f : T ⟶ over D) : factorToChart D i hT f ≫ chartOver D i = f := by
  apply Over.OverMorphism.ext
  exact IsOpenImmersion.lift_fac _ _ _

def chartHomEquiv (i : I) (T : Over S) (hT : ∀ t : T.left, T.hom t ∈ U i) :
    (T ⟶ over D) ≃ (T ⟶ (D i).space) where
  toFun := factorToChart D i hT
  invFun f := f ≫ chartOver D i
  left_inv := factorToChart_chart D i hT
  right_inv f := (cancel_mono (chartOver D i)).mp (factorToChart_chart D i hT (f ≫ chartOver D i))

theorem classifies_on_base_open (u : F.obj (op (over D))) (i : I)
    (hu : F.map (chartOver D i).op u = (D i).sectionValue)
    (T : Over S) [IsReduced T.left] (hT : ∀ t : T.left, T.hom t ∈ U i) :
    Function.Bijective (fun f : T ⟶ over D => F.map f.op u) := by
  have hb := ((D i).classifies T hT).comp (chartHomEquiv D i T hT).bijective
  convert hb using 1
  funext f
  change F.map f.op u = F.map (factorToChart D i hT f).op (D i).sectionValue
  rw [← hu, ← F.map_comp_apply]
  exact congrArg (fun q : T ⟶ over D => F.map q.op u) (factorToChart_chart D i hT f).symm

end ReducedRepresentationAtlas

end AlgebraicGeometry.PELModuli.IntegralModel.Reduced.RepresentationAtlas

end

end OAI