File size: 5,914 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
import OAI.ArithmeticGeometry.Models.SpreadingOut.Finite

/-! # Diagram -/

namespace OAI.ArithmeticGeometry.Models.SpreadingOut.Diagram.Construction

noncomputable section

/-! Simultaneous arithmetic models with compatible specified morphisms. -/

open _root_.CategoryTheory _root_.CategoryTheory.Limits _root_.AlgebraicGeometry
open scoped _root_.NumberField

universe u v w

theorem coefficient_arithmetic_base
    {K : Type u} [Field K] [NumberField K] (s : Finset K) :
    βˆƒ (B : Base.Construction.ArithmeticOpen K) (b : B.U.toScheme ⟢ CoefficientSystem.Constructions.Foundations.coefficientBase (π“ž K) K s),
      B.generic ≫ b = CoefficientSystem.Constructions.Foundations.genericBaseMap (π“ž K) K s := by
  let A := CoefficientSystem.Constructions.Foundations.coefficientRing (π“ž K) K s
  obtain ⟨d, hd, hpow, hle⟩ := Fg.Construction.fg_subalgebra_le_localization A ⟨s, rfl⟩
  let Rβ‚€ := Localization.subalgebra.ofField K (Submonoid.powers d) hpow
  let Ο† : A →ₐ[π“ž K] Rβ‚€ := Subalgebra.inclusion hle
  let f := Spec.map (CommRingCat.ofHom Ο†.toRingHom)
  let g := Spec.map (CommRingCat.ofHom (algebraMap Rβ‚€ K))
  have hgf : g ≫ f = CoefficientSystem.Constructions.Foundations.genericBaseMap (π“ž K) K s := by
    rw [← Spec.map_comp]
    rfl
  let B := Base.Construction.arithmeticOpenOfNonzero K d hd
  let j : Spec (.of Rβ‚€) β‰… B.U.toScheme := Affine.Construction.localizationOpenIso (π“ž K) Rβ‚€ d
  have hj : j.hom ≫ B.U.ΞΉ = Spec.map (CommRingCat.ofHom (algebraMap (π“ž K) Rβ‚€)) :=
    Affine.Construction.localizationOpenIso_hom_ΞΉ (π“ž K) Rβ‚€ d
  have hg : g ≫ j.hom = B.generic := by
    apply (cancel_mono B.U.ΞΉ).mp
    rw [Category.assoc, hj, B.generic_eq]
    change Spec.map (CommRingCat.ofHom (algebraMap Rβ‚€ K)) ≫
      Spec.map (CommRingCat.ofHom (algebraMap (π“ž K) Rβ‚€)) = _
    rw [← Spec.map_comp]
    congr 1
  refine ⟨B, j.inv ≫ f, ?_⟩
  rw [← hg, Category.assoc, Iso.hom_inv_id_assoc, hgf]

theorem cartesian_generic_iso_compatibility
    {S T : Scheme.{u}} (g : T ⟢ S) {X Y : Over T} {M N : Over S}
    (p : X.left ⟢ M.left) (q : Y.left ⟢ N.left)
    (hp : IsPullback p X.hom M.hom g) (hq : IsPullback q Y.hom N.hom g)
    (f : X ⟢ Y) (a : M ⟢ N) (ha : p ≫ a.left = f.left ≫ q) :
    (Over.pullback g).map a ≫ (Over.isoMk hq.isoPullback.symm hq.isoPullback_inv_snd).hom =
      (Over.isoMk hp.isoPullback.symm hp.isoPullback_inv_snd).hom ≫ f := by
  let eX : (Over.pullback g).obj M β‰… X :=
    Over.isoMk hp.isoPullback.symm hp.isoPullback_inv_snd
  let eY : (Over.pullback g).obj N β‰… Y :=
    Over.isoMk hq.isoPullback.symm hq.isoPullback_inv_snd
  change (Over.pullback g).map a ≫ eY.hom = eX.hom ≫ f
  apply (cancel_epi eX.inv).mp
  apply (cancel_mono eY.inv).mp
  simp only [Category.assoc, Iso.hom_inv_id, Category.comp_id, Iso.inv_hom_id_assoc]
  apply Over.OverMorphism.ext
  apply pullback.hom_ext
  Β· change (hp.isoPullback.hom ≫ ((Over.pullback g).map a).left) ≫ pullback.fst N.hom g =
      (f.left ≫ hq.isoPullback.hom) ≫ pullback.fst N.hom g
    erw [Category.assoc, pullback.lift_fst, ← Category.assoc, hp.isoPullback_hom_fst,
      Category.assoc, hq.isoPullback_hom_fst]
    exact ha
  Β· change (hp.isoPullback.hom ≫ ((Over.pullback g).map a).left) ≫ pullback.snd N.hom g =
      (f.left ≫ hq.isoPullback.hom) ≫ pullback.snd N.hom g
    erw [Category.assoc, pullback.lift_snd, hp.isoPullback_hom_snd,
      Category.assoc, hq.isoPullback_hom_snd]
    exact f.w.symm

theorem finite_smooth_proper_diagram_arithmetic_model
    {K : Type u} [Field K] [NumberField K] {ΞΉ : Type v} {Ξ± : Type w}
    [Finite ΞΉ] [Finite Ξ±]
    (X : ΞΉ β†’ Over (Base.Construction.fieldBase K)) (hs : βˆ€ i, Smooth (X i).hom)
    (hp : βˆ€ i, IsProper (X i).hom) (src dst : Ξ± β†’ ΞΉ)
    (f : βˆ€ a, X (src a) ⟢ X (dst a)) :
    βˆƒ (B : Base.Construction.ArithmeticOpen K) (M : ΞΉ β†’ Over B.U.toScheme)
      (fM : βˆ€ a, M (src a) ⟢ M (dst a))
      (e : βˆ€ i, (Over.pullback B.generic).obj (M i) β‰… X i),
      (βˆ€ i, Smooth (M i).hom ∧ IsProper (M i).hom) ∧
      (βˆ€ a, (Over.pullback B.generic).map (fM a) ≫ (e (dst a)).hom =
        (e (src a)).hom ≫ f a) := by
  obtain ⟨s, M, p, fM, hM, hcart, hfM⟩ :=
    SpreadingOut.Finite.Construction.finite_smooth_proper_arrows_coefficient_model X hs hp src dst f
  let g := CoefficientSystem.Constructions.Foundations.genericBaseMap (π“ž K) K s
  let e (i : ΞΉ) : (Over.pullback g).obj (M i) β‰… X i :=
    Over.isoMk (hcart i).isoPullback.symm (hcart i).isoPullback_inv_snd
  have he (a : Ξ±) : (Over.pullback g).map (fM a) ≫ (e (dst a)).hom =
      (e (src a)).hom ≫ f a :=
    cartesian_generic_iso_compatibility g _ _ (hcart _) (hcart _) (f a) (fM a) (hfM a)
  obtain ⟨B, b, hb⟩ := coefficient_arithmetic_base s
  let F := Over.pullback b
  let G := Over.pullback B.generic
  let c : F β‹™ G β‰… Over.pullback g :=
    (Over.pullbackComp B.generic b).symm β‰ͺ≫
      eqToIso (congrArg (fun k : Base.Construction.fieldBase K ⟢ CoefficientSystem.Constructions.Foundations.coefficientBase (π“ž K) K s ↦ Over.pullback k) hb)
  refine ⟨B, (fun i ↦ F.obj (M i)), (fun a ↦ F.map (fM a)),
    (fun i ↦ c.app (M i) β‰ͺ≫ e i), ?_, ?_⟩
  Β· intro i
    have := (hM i).1
    have := (hM i).2
    exact ⟨inferInstanceAs (Smooth (pullback.snd (M i).hom b)),
      inferInstanceAs (IsProper (pullback.snd (M i).hom b))⟩
  Β· intro a
    have hc : G.map (F.map (fM a)) ≫ (c.app (M (dst a))).hom =
        (c.app (M (src a))).hom ≫ (Over.pullback g).map (fM a) :=
      c.hom.naturality (fM a)
    change G.map (F.map (fM a)) ≫ (c.app (M (dst a))).hom ≫ (e (dst a)).hom =
      ((c.app (M (src a))).hom ≫ (e (src a)).hom) ≫ f a
    rw [← Category.assoc, hc, Category.assoc, he,
      Category.assoc]

end

end OAI.ArithmeticGeometry.Models.SpreadingOut.Diagram.Construction