File size: 17,197 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 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 | import OAI.AlgebraicGeometry.ComplexPoints.Analytic.SchemePointHomeomorphs
import OAI.AlgebraicGeometry.ComplexPoints.Analytic.OpenImmersion
import OAI.AlgebraicGeometry.ComplexPoints.Analytic.ProjectiveCountability
import OAI.AlgebraicGeometry.ComplexPoints.Analytic.PolynomialEvaluation
import OAI.AlgebraicGeometry.ComplexPoints.Analytic.ProjectiveCharts
import OAI.AlgebraicGeometry.Foundations.Scheme.ProjectiveChart
import OAI.AlgebraicGeometry.Foundations.Scheme.ProjectiveChartPoint
import OAI.AlgebraicGeometry.Foundations.Scheme.ProjectivePointInjective
import OAI.AlgebraicGeometry.Foundations.Scheme.ProjectivePointSurjective
import OAI.AlgebraicGeometry.Foundations.Scheme.ProjectiveComplexPoints
/-! # Projective Scheme -/
namespace OAI.AlgebraicGeometry.ComplexPoints.Analytic
noncomputable section
/-!
# Ordinary complex points of the genuine projective scheme
The carrier on the scheme side is the actual type of morphisms over `Spec β`.
Its topology is the affine-test topology from `SchemePoints`. The coordinate
chart maps below use the proved scheme isomorphisms of standard Proj opens.
-/
open _root_.CategoryTheory _root_.AlgebraicGeometry
section
/-- An isomorphism of actual complex schemes induces a homeomorphism of their
complex-valued points with the affine-test topology. -/
def SchemePointHomeomorphs.schemeComplexPoints.homeomorphOfIso {X Y : Over Foundations.Scheme.ProjectiveSpace.complexBase} (e : X β
Y) :
SchemePointHomeomorphs.schemeComplexPoints X ββ SchemePointHomeomorphs.schemeComplexPoints Y where
toFun := SchemePointHomeomorphs.schemeComplexPoints.map e.hom
invFun := SchemePointHomeomorphs.schemeComplexPoints.map e.inv
left_inv x := by simp [SchemePointHomeomorphs.schemeComplexPoints.map, Category.assoc]
right_inv x := by simp [SchemePointHomeomorphs.schemeComplexPoints.map, Category.assoc]
continuous_toFun := SchemePointHomeomorphs.schemeComplexPoints.continuous_map e.hom
continuous_invFun := SchemePointHomeomorphs.schemeComplexPoints.continuous_map e.inv
@[simp]
theorem SchemePointHomeomorphs.schemeComplexPoints.homeomorphOfIso_apply {X Y : Over Foundations.Scheme.ProjectiveSpace.complexBase} (e : X β
Y)
(x : SchemePointHomeomorphs.schemeComplexPoints X) : SchemePointHomeomorphs.schemeComplexPoints.homeomorphOfIso e x = x β« e.hom := rfl
end
/-- The genuine complex-valued points of standard projective n-space. -/
abbrev ProjectiveScheme.projectiveSchemeComplexPoints (n : β) :=
SchemePointHomeomorphs.schemeComplexPoints (Over.mk (Foundations.Scheme.ProjectiveSpace.projectiveSpaceToBase n))
/-- The nonzero-vector construction, descended to ordinary projective space,
viewed as an actual point over the complex base. -/
def ProjectiveScheme.projectivizationSchemePoint (n : β)
(p : Projectivization β (Fin (n + 1) β β)) : ProjectiveScheme.projectiveSchemeComplexPoints n :=
Over.homMk (Foundations.Scheme.ProjectiveVectorScale.projectivizationPoint n p) (Foundations.Scheme.ProjectiveVectorScale.projectivizationPoint_over_base p)
@[simp]
theorem ProjectiveScheme.projectivizationSchemePoint_left (n : β)
(p : Projectivization β (Fin (n + 1) β β)) :
(ProjectiveScheme.projectivizationSchemePoint n p).left = Foundations.Scheme.ProjectiveVectorScale.projectivizationPoint n p := rfl
/-- The map into actual complex scheme points is injective. -/
theorem ProjectiveScheme.projectivizationSchemePoint_injective (n : β) :
Function.Injective (ProjectiveScheme.projectivizationSchemePoint n) := by
intro p q h
apply Foundations.Scheme.ProjectivePointInjective.projectivizationPoint_injective n
exact congrArg (fun x : ProjectiveScheme.projectiveSchemeComplexPoints n => x.left) h
/-- Membership in the actual coordinate open agrees with the ordinary
nonvanishing-coordinate patch under the homogeneous-coordinate map. -/
theorem ProjectiveScheme.projectivizationSchemePoint_mem_coordinateOpen (n : β)
(i : Fin (n + 1)) (p : Projectivization β (Fin (n + 1) β β)) :
(ProjectiveScheme.projectivizationSchemePoint n p).left (default : Foundations.Scheme.ProjectiveSpace.complexBase) β
Foundations.Scheme.ProjectiveCoordinateCover.projectiveCoordinateOpen n i β
Foundations.Scheme.ProjectiveCoordinatesIn.Algebraic.ProjectiveCoordinates.InPatch i p := by
induction p using Projectivization.ind with
| h v hv =>
change Foundations.Scheme.ProjectiveVectorPoint.projectiveVectorPoint v hv (default : Foundations.Scheme.ProjectiveSpace.complexBase) β
Foundations.Scheme.ProjectiveCoordinateCover.projectiveCoordinateOpen n i β
Foundations.Scheme.ProjectiveCoordinatesIn.Algebraic.ProjectiveCoordinates.InPatch i (Projectivization.mk β v hv)
rw [Foundations.Scheme.ProjectiveCoordinatesIn.Algebraic.ProjectiveCoordinates.inPatch_mk_iff]
exact Foundations.Scheme.ProjectiveVectorPoint.projectiveVectorPoint_mem_coordinateOpen_iff v hv i _
/-- The standard affine chart embedding as a morphism over `Spec β`. -/
def ProjectiveScheme.projectiveAffineChartOverMap (n : β) (i : Fin (n + 1)) :
Foundations.Scheme.AffineComplexPoints.affineSchemeOver β (Foundations.Scheme.ProjectiveChartToPolynomial.projectiveChartPolynomial n i) βΆ
Over.mk (Foundations.Scheme.ProjectiveSpace.projectiveSpaceToBase n) :=
Over.homMk (Foundations.Scheme.ProjectiveChart.projectiveAffineChartMap n i) (Foundations.Scheme.ProjectiveChart.projectiveAffineChartMap_over n i)
/-- The over-category chart map is still an actual open immersion. -/
instance ProjectiveScheme.projectiveAffineChartOverMap_isOpenImmersion (n : β) (i : Fin (n + 1)) :
IsOpenImmersion (ProjectiveScheme.projectiveAffineChartOverMap n i).left := by
change IsOpenImmersion (Foundations.Scheme.ProjectiveChart.projectiveAffineChartMap n i)
infer_instance
/-- The points of a genuine Proj coordinate open have their usual affine
coordinate topology, by the actual scheme chart isomorphism. -/
def ProjectiveScheme.projectiveCoordinatePointHomeomorph (n : β) (i : Fin (n + 1)) :
SchemePointHomeomorphs.schemeComplexPoints
(Over.mk ((Foundations.Scheme.ProjectiveCoordinateCover.projectiveCoordinateOpen n i).ΞΉ β« Foundations.Scheme.ProjectiveSpace.projectiveSpaceToBase n)) ββ
({j : Fin (n + 1) // j β i} β β) :=
(SchemePointHomeomorphs.schemeComplexPoints.homeomorphOfIso (Foundations.Scheme.ProjectiveChart.projectiveCoordinateOverIso n i)).trans
((SchemePointHomeomorphs.affineSchemePointHomeomorph (Foundations.Scheme.ProjectiveChartToPolynomial.projectiveChartPolynomial n i)).symm.trans
(PolynomialEvaluation.polynomialPointHomeomorph {j : Fin (n + 1) // j β i}))
/-- Ordinary affine coordinates define actual projective scheme points through
the corresponding genuine affine chart embedding. -/
def ProjectiveScheme.projectiveAffineSchemePoint (n : β) (i : Fin (n + 1))
(z : {j : Fin (n + 1) // j β i} β β) : ProjectiveScheme.projectiveSchemeComplexPoints n :=
SchemePointHomeomorphs.schemeComplexPoints.affinePointMap (CommAlgCat.of β (Foundations.Scheme.ProjectiveChartToPolynomial.projectiveChartPolynomial n i))
(ProjectiveScheme.projectiveAffineChartOverMap n i)
((PolynomialEvaluation.polynomialPointHomeomorph {j : Fin (n + 1) // j β i}).symm z)
/-- This chart construction is continuous in ordinary complex coordinates. -/
theorem ProjectiveScheme.continuous_projectiveAffineSchemePoint (n : β) (i : Fin (n + 1)) :
Continuous (ProjectiveScheme.projectiveAffineSchemePoint n i) :=
(SchemePointHomeomorphs.schemeComplexPoints.continuous_affinePointMap
(CommAlgCat.of β (Foundations.Scheme.ProjectiveChartToPolynomial.projectiveChartPolynomial n i))
(ProjectiveScheme.projectiveAffineChartOverMap n i)).comp
(PolynomialEvaluation.polynomialPointHomeomorph {j : Fin (n + 1) // j β i}).symm.continuous
/-- The chart map on scheme morphisms is exactly polynomial evaluation followed
by the genuine affine chart insertion. -/
@[simp]
theorem ProjectiveScheme.projectiveAffineSchemePoint_left (n : β) (i : Fin (n + 1))
(z : {j : Fin (n + 1) // j β i} β β) :
(ProjectiveScheme.projectiveAffineSchemePoint n i z).left =
Spec.map (CommRingCat.ofHom (MvPolynomial.eval z)) β« Foundations.Scheme.ProjectiveChart.projectiveAffineChartMap n i := by
change (Foundations.Scheme.AffineComplexPoints.affineComplexPointsOverEquiv (Foundations.Scheme.ProjectiveChartToPolynomial.projectiveChartPolynomial n i)
((PolynomialEvaluation.polynomialPointHomeomorph {j : Fin (n + 1) // j β i}).symm z)).left β«
Foundations.Scheme.ProjectiveChart.projectiveAffineChartMap n i = _
rw [Foundations.Scheme.AffineComplexPoints.affineComplexPointsOverEquiv_left]
rfl
/-- The affine scheme chart and the ordinary projective affine chart give
exactly the same complex-valued scheme point. -/
theorem ProjectiveScheme.projectiveAffineSchemePoint_eq_projectivization (n : β)
(i : Fin (n + 1)) (z : {j : Fin (n + 1) // j β i} β β) :
ProjectiveScheme.projectiveAffineSchemePoint n i z =
ProjectiveScheme.projectivizationSchemePoint n ((ProjectiveCharts.projectiveAffineChart i).symm z).val := by
apply Over.OverMorphism.ext
rw [ProjectiveScheme.projectiveAffineSchemePoint_left, ProjectiveScheme.projectivizationSchemePoint_left]
change Spec.map (CommRingCat.ofHom (MvPolynomial.eval z)) β« Foundations.Scheme.ProjectiveChart.projectiveAffineChartMap n i =
Foundations.Scheme.ProjectiveVectorPoint.projectiveVectorPoint (Foundations.Scheme.DehomogenizationC.Algebraic.Dehomogenization.insertOne i z) (Foundations.Scheme.ProjectiveChartPoint.insertOne_ne_zero n i z)
exact Foundations.Scheme.ProjectiveChartPoint.projectiveAffineChartMap_eval_eq_vectorPoint n i z (Foundations.Scheme.ProjectiveChartPoint.insertOne_ne_zero n i z)
/-- On an ordinary coordinate patch, the global scheme-point map is given by
the genuine scheme chart followed by its ordinary affine coordinates. -/
theorem ProjectiveScheme.projectivizationSchemePoint_on_patch (n : β) (i : Fin (n + 1))
(p : {p : Projectivization β (Fin (n + 1) β β) //
Foundations.Scheme.ProjectiveCoordinatesIn.Algebraic.ProjectiveCoordinates.InPatch i p}) :
ProjectiveScheme.projectivizationSchemePoint n p.val =
ProjectiveScheme.projectiveAffineSchemePoint n i (ProjectiveCharts.projectiveAffineChart i p) := by
simpa only [Homeomorph.symm_apply_apply] using
(ProjectiveScheme.projectiveAffineSchemePoint_eq_projectivization n i
(ProjectiveCharts.projectiveAffineChart i p)).symm
/-- Ordinary homogeneous coordinates vary continuously as genuine scheme
points equipped with the affine-test topology. -/
theorem ProjectiveScheme.continuous_projectivizationSchemePoint (n : β) :
Continuous (ProjectiveScheme.projectivizationSchemePoint n) := by
apply continuous_of_cover_nhds
(s := fun i : Fin (n + 1) =>
{p : Projectivization β (Fin (n + 1) β β) |
Foundations.Scheme.ProjectiveCoordinatesIn.Algebraic.ProjectiveCoordinates.InPatch i p})
Β· intro p
obtain β¨i, hiβ© := Foundations.Scheme.ProjectiveCoordinatesIn.Algebraic.ProjectiveCoordinates.exists_inPatch p
exact β¨i, (ProjectiveCharts.isOpen_projectivePatch i).mem_nhds hiβ©
Β· intro i
apply continuousOn_iff_continuous_domRestrict.mpr
change Continuous (fun p : {p : Projectivization β (Fin (n + 1) β β) //
Foundations.Scheme.ProjectiveCoordinatesIn.Algebraic.ProjectiveCoordinates.InPatch i p} => ProjectiveScheme.projectivizationSchemePoint n p.val)
have heq : (fun p : {p : Projectivization β (Fin (n + 1) β β) //
Foundations.Scheme.ProjectiveCoordinatesIn.Algebraic.ProjectiveCoordinates.InPatch i p} => ProjectiveScheme.projectivizationSchemePoint n p.val) =
(fun p => ProjectiveScheme.projectiveAffineSchemePoint n i (ProjectiveCharts.projectiveAffineChart i p)) :=
funext (ProjectiveScheme.projectivizationSchemePoint_on_patch n i)
rw [heq]
exact (ProjectiveScheme.continuous_projectiveAffineSchemePoint n i).comp
(ProjectiveCharts.projectiveAffineChart i).continuous
/-- Every genuine complex-valued point of the projective scheme has nonzero
homogeneous coordinates. -/
theorem ProjectiveScheme.projectivizationSchemePoint_surjective (n : β) :
Function.Surjective (ProjectiveScheme.projectivizationSchemePoint n) := by
intro p
obtain β¨q, hqβ© := Foundations.Scheme.ProjectivePointSurjective.exists_projectivizationPoint p.left (Over.w p)
refine β¨q, ?_β©
apply Over.OverMorphism.ext
exact hq
/-- The genuine complex-valued points of projective n-space are compact for
their affine-test topology, as a continuous image of ordinary projective space. -/
instance ProjectiveScheme.projectiveSchemeComplexPoints_compactSpace (n : β) :
CompactSpace (ProjectiveScheme.projectiveSchemeComplexPoints n) :=
Function.Surjective.compactSpace (ProjectiveScheme.continuous_projectivizationSchemePoint n)
(ProjectiveScheme.projectivizationSchemePoint_surjective n)
/-- Standard affine coordinates map openly into the actual projective
scheme-point space, because the scheme chart is an open immersion. -/
theorem ProjectiveScheme.isOpenMap_projectiveAffineSchemePoint (n : β) (i : Fin (n + 1)) :
IsOpenMap (ProjectiveScheme.projectiveAffineSchemePoint n i) :=
((SchemePointHomeomorphs.schemeComplexPoints.isOpenMap_map_of_isOpenImmersion
(ProjectiveScheme.projectiveAffineChartOverMap n i)).comp
(SchemePointHomeomorphs.affineSchemePointHomeomorph (Foundations.Scheme.ProjectiveChartToPolynomial.projectiveChartPolynomial n i)).isOpenMap).comp
(PolynomialEvaluation.polynomialPointHomeomorph {j : Fin (n + 1) // j β i}).symm.isOpenMap
/-- The homogeneous-coordinate map is open, as seen on the genuine standard
coordinate charts covering ordinary projective space. -/
theorem ProjectiveScheme.isOpenMap_projectivizationSchemePoint (n : β) :
IsOpenMap (ProjectiveScheme.projectivizationSchemePoint n) := by
let s : Fin (n + 1) β Set (Projectivization β (Fin (n + 1) β β)) :=
fun i => {p | Foundations.Scheme.ProjectiveCoordinatesIn.Algebraic.ProjectiveCoordinates.InPatch i p}
have hloc (i : Fin (n + 1)) :
IsOpenMap (fun p : s i => ProjectiveScheme.projectivizationSchemePoint n p.val) := by
have heq : (fun p : s i => ProjectiveScheme.projectivizationSchemePoint n p.val) =
(fun p : s i => ProjectiveScheme.projectiveAffineSchemePoint n i
(ProjectiveCharts.projectiveAffineChart i p)) :=
funext (ProjectiveScheme.projectivizationSchemePoint_on_patch n i)
rw [heq]
exact (ProjectiveScheme.isOpenMap_projectiveAffineSchemePoint n i).comp
(ProjectiveCharts.projectiveAffineChart i).isOpenMap
intro U hU
have himg : ProjectiveScheme.projectivizationSchemePoint n '' U =
β i : Fin (n + 1), (fun p : s i => ProjectiveScheme.projectivizationSchemePoint n p.val) ''
((Subtype.val : s i β Projectivization β (Fin (n + 1) β β)) β»ΒΉ' U) := by
ext q
constructor
Β· rintro β¨p, hp, hpqβ©
obtain β¨i, hiβ© := Foundations.Scheme.ProjectiveCoordinatesIn.Algebraic.ProjectiveCoordinates.exists_inPatch p
exact Set.mem_iUnion.mpr β¨i, β¨β¨p, hiβ©, hp, hpqβ©β©
Β· intro hq
obtain β¨i, p, hp, hpqβ© := Set.mem_iUnion.mp hq
exact β¨p.val, hp, hpqβ©
rw [himg]
exact isOpen_iUnion fun i => hloc i _ (hU.preimage continuous_subtype_val)
/-- Ordinary complex projective space is homeomorphic to the actual complex
points of the standard projective scheme with their independently defined
affine-test topology. -/
def ProjectiveScheme.projectiveSchemePointHomeomorph (n : β) :
Projectivization β (Fin (n + 1) β β) ββ ProjectiveScheme.projectiveSchemeComplexPoints n :=
(Foundations.Scheme.ProjectiveComplexPoints.projectiveComplexPointsEquiv n).toHomeomorphOfContinuousOpen
(ProjectiveScheme.continuous_projectivizationSchemePoint n) (ProjectiveScheme.isOpenMap_projectivizationSchemePoint n)
/-- The topological comparison has the genuine homogeneous-coordinate map as
its forward function. -/
@[simp]
theorem ProjectiveScheme.projectiveSchemePointHomeomorph_apply (n : β)
(p : Projectivization β (Fin (n + 1) β β)) :
ProjectiveScheme.projectiveSchemePointHomeomorph n p = ProjectiveScheme.projectivizationSchemePoint n p := rfl
/-- Actual projective scheme complex points are Hausdorff for the existing
ordinary affine-test topology. -/
instance ProjectiveScheme.projectiveSchemeComplexPoints_t2Space (n : β) :
T2Space (ProjectiveScheme.projectiveSchemeComplexPoints n) :=
(ProjectiveScheme.projectiveSchemePointHomeomorph n).symm.isEmbedding.t2Space
/-- Actual projective scheme complex points have a countable topological basis. -/
instance ProjectiveScheme.projectiveSchemeComplexPoints_secondCountableTopology (n : β) :
SecondCountableTopology (ProjectiveScheme.projectiveSchemeComplexPoints n) :=
(ProjectiveScheme.projectiveSchemePointHomeomorph n).symm.secondCountableTopology
end
end OAI.AlgebraicGeometry.ComplexPoints.Analytic
|