File size: 4,100 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
import OAI.ArithmeticGeometry.Models.SpreadingOut.CoefficientSmoothness
import OAI.ArithmeticGeometry.Models.BaseChange

/-! # Coefficient -/

namespace OAI.ArithmeticGeometry.Models.SpreadingOut.Coefficient.Construction

noncomputable section

/-! A proper coefficient model of a smooth scheme gives the exact
smooth-proper arithmetic model required in SpreadingOut. -/

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

universe u

open OAI.ArithmeticGeometry.Models.BaseChange.Constructions.Foundations

theorem smooth_proper_coefficient_model_to_arithmetic
    {K : Type u} [Field K] [NumberField K]
    {X : Over (Spec (.of K))} (M : Foundations.Constructions.CoefficientModel K X)
    [Smooth M.model.hom] [IsProper M.model.hom] :
    βˆƒ (B : Base.Construction.ArithmeticOpen K) (N : Over B.U.toScheme),
      Smooth N.hom ∧ IsProper N.hom ∧
      Nonempty ((Over.pullback B.generic).obj N β‰… X) := by
  let A := CoefficientSystem.Constructions.Foundations.coefficientRing (π“ž K) K M.coefficients
  obtain ⟨d, hd, hpow, hle⟩ := Fg.Construction.fg_subalgebra_le_localization A
    ⟨M.coefficients, 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 Mβ‚€ := (Over.pullback f).obj M.model
  let g := Spec.map (CommRingCat.ofHom (algebraMap Rβ‚€ K))
  have hgf : g ≫ f = CoefficientSystem.Constructions.Foundations.genericBaseMap (π“ž K) K M.coefficients := 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
  let N := (Over.map j.hom).obj Mβ‚€
  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
  have : Smooth Mβ‚€.hom := inferInstanceAs (Smooth (pullback.snd M.model.hom f))
  have : IsProper Mβ‚€.hom := inferInstanceAs (IsProper (pullback.snd M.model.hom f))
  refine ⟨B, N, ?_, ?_, ?_⟩
  Β· change Smooth (Mβ‚€.hom ≫ j.hom)
    infer_instance
  Β· change IsProper (Mβ‚€.hom ≫ j.hom)
    infer_instance
  Β· rw [← hg]
    exact ⟨Affine.Construction.baseChangeAlongIso Mβ‚€ j g β‰ͺ≫ BaseChange.Constructions.Foundations.iteratedBaseChangeIso f g M.model β‰ͺ≫
      Scheme.Constructions.Foundations.baseChangeCongr hgf M.model β‰ͺ≫ M.genericIso⟩

/-- Properness is the only remaining model-existence obligation for the
first SpreadingOut conclusion: generic smoothness supplies smoothness after shrinking. -/
theorem proper_coefficient_model_to_arithmetic
    {K : Type u} [Field K] [NumberField K]
    {X : Over (Spec (.of K))} [Smooth X.hom]
    (M : Foundations.Constructions.CoefficientModel K X) [IsProper M.model.hom] :
    βˆƒ (B : Base.Construction.ArithmeticOpen K) (N : Over B.U.toScheme),
      Smooth N.hom ∧ IsProper N.hom ∧
      Nonempty ((Over.pullback B.generic).obj N β‰… X) := by
  have : IsIso M.genericIso.hom.left :=
    inferInstanceAs (IsIso ((Over.forget _).map M.genericIso.hom))
  have hs : Smooth (M.genericIso.hom.left ≫ X.hom) := inferInstance
  rw [M.genericIso.hom.w] at hs
  have := hs
  obtain ⟨t, h, hsm⟩ := CoefficientSmoothness.Construction.proper_coefficient_model_eventually_smooth M.model
  let N := M.enlarge t h
  have : Smooth N.model.hom := hsm
  have : IsProper N.model.hom :=
    inferInstanceAs (IsProper (pullback.snd M.model.hom (CoefficientSystem.Constructions.Foundations.coefficientBaseMap (π“ž K) K h)))
  exact smooth_proper_coefficient_model_to_arithmetic N

end

end OAI.ArithmeticGeometry.Models.SpreadingOut.Coefficient.Construction