File size: 4,443 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
import Mathlib.AlgebraicGeometry.Limits
import Mathlib.AlgebraicGeometry.Pullbacks
import Mathlib.CategoryTheory.Extensive

/-! # Partition Base Maps -/

namespace OAI.AlgebraicGeometry.PELModuli.IntegralModel.Finite.PartitionBaseMaps

noncomputable section

section

/-! Products with a fixed scheme over the base preserve a finite
disjoint decomposition of the parameter scheme. -/

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

namespace FiniteBasePartition
variable {S : Scheme.{0}} {I : Type} [Finite I]
    (U : I → Over S) (T : Over S) (j : ∀ i, U i ⟶ T)
    (H : IsColimit (Cofan.mk T.left (fun i => (j i).left)))

def productCofanIsColimit (X : Over S) :
    IsColimit (Cofan.mk (T ⨯ X).left (fun i => (prod.map (j i) (𝟙 X)).left)) := by
  have hP (V : Over S) : IsPullback (prod.snd : V ⨯ X ⟶ X).left
      (prod.fst : V ⨯ X ⟶ V).left X.hom V.hom :=
    (Over.isPullback_of_binaryFan_isLimit _ (prodIsProd V X)).flip
  let h := FinitaryPreExtensive.isUniversal_finiteCoproducts H
  apply Classical.choice
  refine h.nonempty_isColimit_of_isPullback_left (fun i => (U i).hom) T.hom X.hom
    (fun i => (prod.snd : U i ⨯ X ⟶ X).left)
    (fun i => (prod.fst : U i ⨯ X ⟶ U i).left) (fun i => hP (U i)) (hP T)
    (Cofan.mk (T ⨯ X).left (fun i => (prod.map (j i) (𝟙 X)).left)) (Iso.refl _) ?_ ?_ ?_
  · exact fun i => (j i).w
  · intro i
    change (prod.map (j i) (𝟙 X)).left ≫ (prod.snd : T ⨯ X ⟶ X).left = _
    rw [← Over.comp_left, prod.map_snd, Category.comp_id]
  · intro i
    change (prod.map (j i) (𝟙 X)).left ≫ (prod.fst : T ⨯ X ⟶ T).left = _
    rw [← Over.comp_left, prod.map_fst, Over.comp_left]
    rfl

include H in
theorem product_hom_ext (X Y : Over S) (f g : T ⨯ X ⟶ Y)
    (h : ∀ i, prod.map (j i) (𝟙 X) ≫ f = prod.map (j i) (𝟙 X) ≫ g) : f = g := by
  apply Over.OverMorphism.ext
  apply Cofan.IsColimit.hom_ext (productCofanIsColimit U T j H X)
  intro i
  exact congrArg Over.Hom.left (h i)

def glue (X Y : Over S) (f : ∀ i, U i ⨯ X ⟶ Y) : T ⨯ X ⟶ Y := by
  let C := productCofanIsColimit U T j H X
  let m := Cofan.IsColimit.desc C (fun i => (f i).left)
  refine Over.homMk m ?_
  apply Cofan.IsColimit.hom_ext C
  intro i
  change (prod.map (j i) (𝟙 X)).left ≫ (m ≫ Y.hom) =
    (prod.map (j i) (𝟙 X)).left ≫ (T ⨯ X).hom
  have hm : (prod.map (j i) (𝟙 X)).left ≫ m = (f i).left :=
    Cofan.IsColimit.fac C (fun i => (f i).left) i
  rw [← Category.assoc, hm]
  exact (f i).w.trans (prod.map (j i) (𝟙 X)).w.symm

theorem glue_restrict (X Y : Over S) (f : ∀ i, U i ⨯ X ⟶ Y) (i : I) :
    prod.map (j i) (𝟙 X) ≫ glue U T j H X Y f = f i := by
  apply Over.OverMorphism.ext
  exact Cofan.IsColimit.fac (productCofanIsColimit U T j H X) (fun i => (f i).left) i

end FiniteBasePartition

end

/-! Maps out of a finite disjoint parameter decomposition glue over the
original base, with their exact component restrictions. -/

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

namespace FiniteBasePartition
variable {S : Scheme.{0}} {I : Type}
    (U : I → Over S) (T : Over S) (j : ∀ i, U i ⟶ T)
    (H : IsColimit (Cofan.mk T.left (fun i => (j i).left)))

include H in
theorem base_hom_ext (Y : Over S) (f g : T ⟶ Y)
    (h : ∀ i, j i ≫ f = j i ≫ g) : f = g := by
  apply Over.OverMorphism.ext
  apply Cofan.IsColimit.hom_ext H
  exact fun i => congrArg Over.Hom.left (h i)

def glueBase (Y : Over S) (f : ∀ i, U i ⟶ Y) : T ⟶ Y := by
  let m := Cofan.IsColimit.desc H (fun i => (f i).left)
  refine Over.homMk m ?_
  apply Cofan.IsColimit.hom_ext H
  intro i
  have hm : (j i).left ≫ m = (f i).left := Cofan.IsColimit.fac H (fun i => (f i).left) i
  change (j i).left ≫ (m ≫ Y.hom) = (j i).left ≫ T.hom
  rw [← Category.assoc, hm]
  exact (f i).w.trans (j i).w.symm

theorem glueBase_restrict (Y : Over S) (f : ∀ i, U i ⟶ Y) (i : I) :
    j i ≫ glueBase U T j H Y f = f i := by
  apply Over.OverMorphism.ext
  exact Cofan.IsColimit.fac H (fun i => (f i).left) i

end FiniteBasePartition

end

end OAI.AlgebraicGeometry.PELModuli.IntegralModel.Finite.PartitionBaseMaps