File size: 9,267 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
import Mathlib.RingTheory.DiscreteValuationRing.Basic
import Mathlib.RingTheory.Localization.FractionRing
import Mathlib.RingTheory.HopfAlgebra.Quotient
import Mathlib.RingTheory.HopfAlgebra.TensorProduct
import Mathlib.RingTheory.Flat.TorsionFree
import Mathlib.RingTheory.Flat.Domain
import Mathlib.RingTheory.Localization.BaseChange
import Mathlib.LinearAlgebra.Dimension.Localization
import Mathlib.RingTheory.Ideal.Quotient.Operations
import Mathlib.Tactic

/-! # Schematic Closure -/

namespace OAI.AlgebraicGeometry.GroupSchemes.SchematicClosure

/-!
SchematicClosure: schematic closure, expressed by contraction of a generic Hopf ideal.

The quotient by the contracted ideal embeds in the generic quotient, so it
is torsion-free and hence flat over the DVR. The embedding is a localization
map, which identifies the generic fiber and preserves rank. Its tensor square
is injective by flatness, allowing the generic coideal identity to descend.
All imports are proved mathlib results; the statement stub is not imported.
-/

open scoped TensorProduct nonZeroDivisors

variable {R K A : Type*}
    [CommRing R] [IsDomain R] [IsDiscreteValuationRing R]
    [Field K] [Algebra R K] [IsFractionRing R K]
    [CommRing A] [HopfAlgebra R A]

abbrev genericInclusion : A →ₐ[R] (K ⊗[R] A) :=
  Algebra.TensorProduct.includeRight

abbrev closureIdeal (I : Ideal (K ⊗[R] A)) : Ideal A :=
  Ideal.comap (genericInclusion (R := R) (K := K) (A := A)).toRingHom I

abbrev closureEmbedding (I : Ideal (K ⊗[R] A)) :
    (A ⧸ closureIdeal I) →ₐ[R] ((K ⊗[R] A) ⧸ I) :=
  Ideal.quotientMapₐ I genericInclusion le_rfl

omit [IsDomain R] [IsDiscreteValuationRing R] [IsFractionRing R K] in
lemma closureEmbedding_injective (I : Ideal (K ⊗[R] A)) :
    Function.Injective (closureEmbedding I) :=
  Ideal.quotientMap_injective

lemma closure_flat (I : Ideal (K ⊗[R] A)) :
    Module.Flat R (A ⧸ closureIdeal I) := by
  have : Module.IsTorsionFree R K :=
    Module.isTorsionFree_iff_algebraMap_injective.mpr (IsFractionRing.injective R K)
  have : Module.IsTorsionFree R ((K ⊗[R] A) ⧸ I) :=
    Module.IsTorsionFree.trans (R := K) (S := R)
  have : Module.IsTorsionFree R (A ⧸ closureIdeal I) :=
    (closureEmbedding_injective I).moduleIsTorsionFree _
      (fun r x => (closureEmbedding I).toLinearMap.map_smul r x)
  exact Module.Flat.flat_iff_torsion_eq_bot_of_isBezout.mpr
    (Submodule.isTorsionFree_iff_torsion_eq_bot.mp inferInstance)

omit [IsDomain R] [IsDiscreteValuationRing R] in
lemma closure_localized (I : Ideal (K ⊗[R] A)) :
    IsLocalizedModule R⁰ (closureEmbedding I).toLinearMap where
  map_units := (isLocalizedModule_id R⁰ ((K ⊗[R] A) ⧸ I) K).map_units
  surj y := by
    obtain ⟨x, rfl⟩ := Ideal.Quotient.mk_surjective y
    obtain ⟨⟨a, s⟩, h⟩ :=
      IsLocalizedModule.surj R⁰ (TensorProduct.mk R K A 1) x
    change s.val • x = 1 ⊗ₜ[R] a at h
    refine ⟨(Ideal.Quotient.mk (closureIdeal I) a, s), ?_⟩
    change s • Ideal.Quotient.mk I x = Ideal.Quotient.mk I (1 ⊗ₜ[R] a)
    exact (map_smul (Ideal.Quotient.mkₐ R I) s.val x).symm.trans
      (congrArg (Ideal.Quotient.mk I) h)
  exists_of_eq h := ⟨1, by simpa using closureEmbedding_injective I h⟩

omit [IsDomain R] [IsDiscreteValuationRing R] in
lemma closure_generic_fiber (I : Ideal (K ⊗[R] A)) :
    Ideal.map genericInclusion.toRingHom (closureIdeal I) = I := by
  apply le_antisymm (Ideal.map_le_iff_le_comap.mpr le_rfl)
  intro x hx
  obtain ⟨⟨a, s⟩, h⟩ :=
    IsLocalizedModule.surj R⁰ (TensorProduct.mk R K A 1) x
  change s.val • x = 1 ⊗ₜ[R] a at h
  have ha : a ∈ closureIdeal I := by
    change 1 ⊗ₜ[R] a ∈ I
    rw [← h]
    exact (I.restrictScalars R).smul_mem s.val hx
  have hmem : (algebraMap R K s.val) • x ∈
      Ideal.map genericInclusion.toRingHom (closureIdeal I) := by
    rw [algebraMap_smul]
    rw [h]
    exact Ideal.mem_map_of_mem _ ha
  exact (Submodule.smul_mem_iff_of_isUnit
    ((Ideal.map genericInclusion.toRingHom (closureIdeal I)).restrictScalars K)
    (IsLocalization.map_units K s)).mp hmem

omit [IsDomain R] [IsDiscreteValuationRing R] in
lemma closure_rank (I : Ideal (K ⊗[R] A)) :
    Module.finrank R (A ⧸ closureIdeal I) =
      Module.finrank K ((K ⊗[R] A) ⧸ I) := by
  have := closure_localized I
  rw [IsFractionRing.finrank_right_eq R K ((K ⊗[R] A) ⧸ I)]
  exact (IsLocalizedModule.finrank_eq R⁰ (closureEmbedding I).toLinearMap le_rfl).symm

abbrev tensorToGeneric :
    (A ⊗[R] A) →ₗ[R] ((K ⊗[R] A) ⊗[K] (K ⊗[R] A)) :=
  (TensorProduct.mapOfCompatibleSMul K R R _ _).comp
    (TensorProduct.map genericInclusion.toLinearMap genericInclusion.toLinearMap)

omit [IsDomain R] [IsDiscreteValuationRing R] [IsFractionRing R K] in
lemma comul_genericInclusion (a : A) :
    Coalgebra.comul (R := K) (genericInclusion a) =
      tensorToGeneric (R := R) (K := K) (Coalgebra.comul (R := R) a) := by
  change Coalgebra.comul (R := K) (1 ⊗ₜ[R] a) = _
  rw [TensorProduct.comul_tmul, Bialgebra.comul_one]
  generalize Coalgebra.comul (R := R) a = z
  induction z using TensorProduct.inductionOn with
  | tmul x y => simp [tensorToGeneric, genericInclusion, Algebra.TensorProduct.one_def]
  | add x y hx hy => simp [TensorProduct.tmul_add, hx, hy]

omit [IsDomain R] [IsDiscreteValuationRing R] [IsFractionRing R K] in
lemma antipode_genericInclusion (a : A) :
    HopfAlgebra.antipode K (genericInclusion a) =
      genericInclusion (R := R) (K := K) (HopfAlgebra.antipode R a) := by
  simp [genericInclusion, Algebra.TensorProduct.includeRight_apply,
    TensorProduct.antipode_def]

omit [IsDomain R] [IsDiscreteValuationRing R] [IsFractionRing R K] in
lemma counit_genericInclusion (a : A) :
    Coalgebra.counit (R := K) (genericInclusion (R := R) (K := K) a) =
      algebraMap R K (Coalgebra.counit (R := R) a) := by
  simp [genericInclusion, Algebra.TensorProduct.includeRight_apply,
    Algebra.smul_def]

noncomputable def closureTensorEmbedding (I : Ideal (K ⊗[R] A)) :
    ((A ⧸ closureIdeal I) ⊗[R] (A ⧸ closureIdeal I)) →ₗ[R]
      (((K ⊗[R] A) ⧸ I) ⊗[K] ((K ⊗[R] A) ⧸ I)) :=
  ((IsLocalization.moduleTensorEquiv R⁰ K
    ((K ⊗[R] A) ⧸ I) ((K ⊗[R] A) ⧸ I)).symm.toLinearMap.restrictScalars R).comp
      (TensorProduct.map (closureEmbedding I).toLinearMap (closureEmbedding I).toLinearMap)

lemma closureTensorEmbedding_injective (I : Ideal (K ⊗[R] A)) :
    Function.Injective (closureTensorEmbedding I) := by
  have := closure_flat I
  exact (IsLocalization.moduleTensorEquiv R⁰ K
    ((K ⊗[R] A) ⧸ I) ((K ⊗[R] A) ⧸ I)).symm.injective.comp
      (TensorProduct.map_injective_of_flat_flat_of_isDomain
        (closureEmbedding I).toLinearMap (closureEmbedding I).toLinearMap
        (closureEmbedding_injective I) (closureEmbedding_injective I))

omit [IsDomain R] [IsDiscreteValuationRing R] in
lemma closureTensorEmbedding_comul (I : Ideal (K ⊗[R] A)) (a : A) :
    closureTensorEmbedding I
      (TensorProduct.map (closureIdeal I |>.restrictScalars R).mkQ
        (closureIdeal I |>.restrictScalars R).mkQ (Coalgebra.comul a)) =
    TensorProduct.map (I.restrictScalars K).mkQ (I.restrictScalars K).mkQ
      (Coalgebra.comul (R := K) (genericInclusion a)) := by
  rw [comul_genericInclusion]
  have h : (closureTensorEmbedding I).comp
      (TensorProduct.map (closureIdeal I |>.restrictScalars R).mkQ
        (closureIdeal I |>.restrictScalars R).mkQ) =
      ((TensorProduct.map (I.restrictScalars K).mkQ
        (I.restrictScalars K).mkQ).restrictScalars R).comp tensorToGeneric := by
    ext x y
    rfl
  exact LinearMap.congr_fun h (Coalgebra.comul a)

lemma closure_hopfIdeal (I : Ideal (K ⊗[R] A)) [Ideal.IsHopfIdeal K I] :
    Ideal.IsHopfIdeal R (closureIdeal I) where
  counit_eq_zero {a} ha := by
    apply IsFractionRing.injective R K
    rw [map_zero, ← counit_genericInclusion]
    exact Submodule.IsCoideal.counit_eq_zero (I := I.restrictScalars K) ha
  map_mkQ_comul_eq_zero {a} ha := by
    apply closureTensorEmbedding_injective I
    exact (closureTensorEmbedding_comul I a).trans
      ((Submodule.IsCoideal.map_mkQ_comul_eq_zero
        (I := I.restrictScalars K) ha).trans (map_zero (closureTensorEmbedding I)).symm)
  antipode_mem {a} ha := by
    change genericInclusion (HopfAlgebra.antipode R a) ∈ I
    rw [← antipode_genericInclusion]
    exact Ideal.IsHopfIdeal.antipode_mem (R := K) ha

/-- The closure of a closed generic subgroup is a finite flat subgroup,
with the same generic fiber and scheme-theoretic order. -/
theorem finite_flat_closure_of_generic_subgroup
    [Module.Finite R A] [Module.Flat R A]
    (I : Ideal (K ⊗[R] A))
    [Ideal.IsHopfIdeal K I] :
    let ι : A →+* (K ⊗[R] A) :=
      (Algebra.TensorProduct.includeRight :
        A →ₐ[R] (K ⊗[R] A)).toRingHom
    let J : Ideal A := Ideal.comap ι I
    Ideal.IsHopfIdeal R J ∧
      Module.Finite R (A ⧸ J) ∧
      Module.Flat R (A ⧸ J) ∧
      Ideal.map ι J = I ∧
      Module.finrank R (A ⧸ J) =
        Module.finrank K ((K ⊗[R] A) ⧸ I) := by
  exact ⟨closure_hopfIdeal I, inferInstance, closure_flat I,
    closure_generic_fiber I, closure_rank I⟩

end OAI.AlgebraicGeometry.GroupSchemes.SchematicClosure