File size: 8,629 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
import OAI.AlgebraicGeometry.PELModuli.IntegralModel.PointedFamilySpecialization
import OAI.AlgebraicGeometry.PELModuli.IntegralModel.Arithmetic.Generating
import OAI.AlgebraicGeometry.Quotients.FiniteDescent.AbelianQuotient

/-! # Generating Target -/

namespace OAI.AlgebraicGeometry.PELModuli.IntegralModel.Arithmetic.GeneratingTarget

noncomputable section

/-! An actual arithmetic abelian target of the required Albanese dimension,
with a pointed generating map from the native extension of the fixed source. -/

open _root_.CategoryTheory _root_.CategoryTheory.Limits _root_.AlgebraicGeometry
open _root_.CategoryTheory.MonoidalCategory
open scoped _root_.CategoryTheory.MonObj _root_.CategoryTheory.Obj

open OAI.AlgebraicGeometry.PELModuli.IntegralModel.PointedFamilySpecialization.Coefficients

variable {R : Type} [Field R] [NumberField R] [Algebra R β„‚]

structure ArithmeticGeneratingTarget (B : Base.ArithmeticBaseExtension R (algebraMap R β„‚))
    (X : Over (Spec (.of R))) (xβ‚€ : πŸ™_ (Over (Spec (.of R))) ⟢ X)
    (A : Over (Spec (.of β„‚))) (n m : β„•) where
  target : Quotients.FiniteDescent.AbelianQuotient.Construction.AbelianScheme (Spec (.of B.extension.carrier))
  embedding : target.toOver ⟢ AbelianModuli.HilbertConstruction.Projective.ProjectivePresentations.affineProjectiveSpace B.extension.carrier m
  closedImmersion : IsClosedImmersion embedding.left
  map : (Over.pullback B.fieldExtension).obj X ⟢ target.toOver
  pointed : Section.Comparisons.mappedSection (Over.pullback B.fieldExtension) xβ‚€ ≫ map = 1
  word_surjective : Surjective (Words.DifferenceWords.map map n).left
  dimension : topologicalKrullDim A.left = topologicalKrullDim
    ((Over.pullback (Spec.map (CommRingCat.ofHom B.embedding))).obj target.toOver).left

theorem arithmetic_generating_target_of_parameter
    (X : Over (Spec (.of R))) [Smooth X.hom] [IsProper X.hom] [GeometricallyConnected X.hom]
    (xβ‚€ : πŸ™_ (Over (Spec (.of R))) ⟢ X) (A : Over (Spec (.of β„‚))) [GrpObj A]
    (a : (Over.pullback (Spec.map (CommRingCat.ofHom (algebraMap R β„‚)))).obj X ⟢ A)
    {n m : β„•} (D : PointedGroupFamily.Coefficients.PointedGroupCoefficientFamily R β„‚ X xβ‚€ A a m)
    (B : Base.ArithmeticBaseExtension R (algebraMap R β„‚))
    (p : Over.mk B.fieldExtension ⟢ Fixed.CoefficientModels.Coefficients.coefficientParameter R β„‚ D.coefficients)
    (hw : letI := D.group
      Surjective ((Over.pullback p.left).map (Words.DifferenceWords.map D.map n)).left)
    (hd : topologicalKrullDim A.left = topologicalKrullDim ((Over.pullback
      (Spec.map (CommRingCat.ofHom B.embedding) ≫ p.left)).obj D.target).left) :
    Nonempty (ArithmeticGeneratingTarget B X xβ‚€ A n m) := by
  let groupD : GrpObj D.target := D.group
  have : IsCommMonObj D.target := D.commutative
  have : Smooth D.target.hom := D.smooth
  have : IsProper D.target.hom := D.proper
  let u : Spec (.of B.extension.carrier) ⟢ ArithmeticGeometry.Models.CoefficientSystem.Constructions.Foundations.coefficientBase R β„‚ D.coefficients := p.left
  let P : Over (Spec (.of R)) β₯€ Over (ArithmeticGeometry.Models.CoefficientSystem.Constructions.Foundations.coefficientBase R β„‚ D.coefficients) :=
    Over.pullback (Fixed.CoefficientModels.Coefficients.parameterBaseMap R β„‚ D.coefficients)
  let F : Over (ArithmeticGeometry.Models.CoefficientSystem.Constructions.Foundations.coefficientBase R β„‚ D.coefficients) β₯€ Over (Spec (.of B.extension.carrier)) :=
    Over.pullback u
  let Q : Over (Spec (.of R)) β₯€ Over (Spec (.of B.extension.carrier)) := Over.pullback B.fieldExtension
  let M := P.obj X
  let Y : Over (Spec (.of B.extension.carrier)) := F.obj D.target
  let groupY : GrpObj Y := Functor.grpObjObj (F := F) (G := D.target)
  have : IsCommMonObj Y := inferInstance
  have hsY : Smooth Y.hom := inferInstanceAs (Smooth (pullback.snd D.target.hom u))
  have hpY : IsProper Y.hom := inferInstanceAs (IsProper (pullback.snd D.target.hom u))
  have hpbase : u ≫ Fixed.CoefficientModels.Coefficients.parameterBaseMap R β„‚ D.coefficients = B.fieldExtension := p.w
  let c : P β‹™ F β‰… Q := Group.BaseChangeComparisons.GroupBaseChange.iteratedNatIso
    (Fixed.CoefficientModels.Coefficients.parameterBaseMap R β„‚ D.coefficients) u B.fieldExtension hpbase
  let eX : F.obj M β‰… Q.obj X := c.app X
  let b : Q.obj X ⟢ Y := eX.inv ≫ F.map D.map
  have hx : Section.Comparisons.mappedSection F (Section.Comparisons.mappedSection P xβ‚€) ≫ eX.hom = Section.Comparisons.mappedSection Q xβ‚€ :=
    Section.Comparisons.mappedSection_comp_naturality P F Q c.hom xβ‚€
  have hb : Section.Comparisons.mappedSection Q xβ‚€ ≫ b = 1 :=
    Generating.pointed_map_after_source_iso F (X := M) (Y := D.target) (U := Q.obj X)
      (Section.Comparisons.mappedSection P xβ‚€) (Section.Comparisons.mappedSection Q xβ‚€) eX D.map hx D.pointed
  have hwF : Surjective (Words.DifferenceWords.map (F.map D.map) n).left :=
    Generating.DifferenceWords.surjective_word_of_baseChange u (X := M) (A := D.target) D.map n hw
  have : IsMonHom (Iso.refl Y).hom := inferInstanceAs (IsMonHom (πŸ™ Y))
  have hwB : Surjective (Words.DifferenceWords.map b n).left :=
    Generating.DifferenceWords.surjective_word_of_comparison (X := Q.obj X) (A := Y) (Y := F.obj M) (B := Y)
      b (F.map D.map) eX.symm (Iso.refl Y)
      (by simp only [b, Iso.refl_hom, Category.comp_id, Iso.symm_hom]) n hwF
  have : Smooth (Q.obj X).hom := inferInstanceAs (Smooth (pullback.snd X.hom B.fieldExtension))
  have : GeometricallyConnected (Q.obj X).hom :=
    inferInstanceAs (GeometricallyConnected (pullback.snd X.hom B.fieldExtension))
  have hcY : GeometricallyConnected Y.hom := GeneratingFiberConnectedness.DifferenceWords.target_geometricallyConnected b n
  let Yβ‚€ : Quotients.FiniteDescent.AbelianQuotient.Construction.AbelianScheme (Spec (.of B.extension.carrier)) := {
    toOver := Y
    smooth := hsY
    proper := hpY
    connected := hcY }
  let eP := Generating.affineProjectiveBaseChangeAlong
    (R := ArithmeticGeometry.Models.CoefficientSystem.Constructions.Foundations.coefficientRing R β„‚ D.coefficients) (K := B.extension.carrier) u m
  have : IsIso eP.hom.left := ((Over.forget (Spec (.of B.extension.carrier))).mapIso eP).isIso_hom
  have : IsClosedImmersion (F.map D.embedding).left := MorphismProperty.of_isPullback
    (ArithmeticGeometry.Models.FoundationsPullback.Constructions.pullback_over_map_isPullback u D.embedding).flip D.closedImmersion
  have : IsClosedImmersion eP.hom.left := inferInstance
  have hi : IsClosedImmersion ((F.map D.embedding).left ≫ eP.hom.left) :=
    IsClosedImmersion.comp (F.map D.embedding).left eP.hom.left
  let ψ := Spec.map (CommRingCat.ofHom B.embedding)
  let eC : (Over.pullback (ψ ≫ u)).obj D.target β‰… (Over.pullback ψ).obj Y :=
    (Over.pullbackComp ψ u).app D.target
  have : IsIso eC.hom.left := ((Over.forget (Spec (.of β„‚))).mapIso eC).isIso_hom
  have heC : topologicalKrullDim ((Over.pullback (ψ ≫ u)).obj D.target).left =
      topologicalKrullDim ((Over.pullback ψ).obj Y).left :=
    eC.hom.left.homeomorph.isHomeomorph.topologicalKrullDim_eq
  exact ⟨{
    target := Yβ‚€
    embedding := F.map D.embedding ≫ eP.hom
    closedImmersion := hi
    map := b
    pointed := hb
    word_surjective := hwB
    dimension := hd.trans heC }⟩

/-- Construct the arithmetic generating target directly from the complex
pointed generating map and its projective embedding. -/
theorem arithmetic_generating_target_exists
    (X : Over (Spec (.of R))) [Smooth X.hom] [IsProper X.hom] [GeometricallyConnected X.hom]
    (xβ‚€ : πŸ™_ (Over (Spec (.of R))) ⟢ X)
    (A : Over (Spec (.of β„‚))) [GrpObj A] [IsCommMonObj A] [Smooth A.hom]
    {m : β„•} (i : A ⟢ AbelianModuli.HilbertConstruction.Projective.ProjectivePresentations.affineProjectiveSpace β„‚ m) [IsClosedImmersion i.left]
    (a : (Over.pullback (Spec.map (CommRingCat.ofHom (algebraMap R β„‚)))).obj X ⟢ A)
    (ha : Section.Comparisons.mappedSection (Over.pullback (Spec.map (CommRingCat.ofHom (algebraMap R β„‚)))) xβ‚€ ≫ a = 1)
    (n : β„•) (hn : Surjective (Words.DifferenceWords.map a n).left)
    (N : β„•) (hN : N β‰  0) :
    βˆƒ B : Base.ArithmeticBaseExtension R (algebraMap R β„‚),
      B.denominator = N ∧ Nonempty (ArithmeticGeneratingTarget B X xβ‚€ A n m) := by
  obtain ⟨D, B, p, hB, hw, hd⟩ := PointedFamilySpecialization.Coefficients.arithmetic_generating_family_exists X xβ‚€ A a i ha n hn N hN
  exact ⟨B, hB, arithmetic_generating_target_of_parameter X xβ‚€ A a D B p hw hd⟩

end

end OAI.AlgebraicGeometry.PELModuli.IntegralModel.Arithmetic.GeneratingTarget