File size: 7,500 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
import OAI.AlgebraicGeometry.Foundations.Scheme.ProjectiveVectorScale
import OAI.AlgebraicGeometry.Foundations.Scheme.ProjectiveChart

/-! # Projective Chart Point -/

namespace OAI.AlgebraicGeometry.Foundations.Scheme.ProjectiveChartPoint

noncomputable section

/-!
# Actual affine chart points and normalized homogeneous coordinates

The inverse affine chart of the genuine projective scheme takes an evaluated
affine point to the vector point obtained by inserting a coordinate equal to one.
-/

open _root_.CategoryTheory _root_.AlgebraicGeometry

open OAI.AlgebraicGeometry.Foundations.Scheme.DehomogenizationC.Algebraic.Dehomogenization

/-- The scheme point obtained by evaluating the polynomial coordinates of a
standard affine chart and then including the chart in projective space. -/
def projectiveAffinePoint (n : β„•) (i : Fin (n + 1))
    (a : {j : Fin (n + 1) // j β‰  i} β†’ β„‚) : ProjectiveSpace.complexBase ⟢ ProjectiveSpace.projectiveSpace n :=
  Spec.map (CommRingCat.ofHom (MvPolynomial.eval a)) ≫ ProjectiveChart.projectiveAffineChartMap n i

@[reassoc (attr := simp)]
theorem projectiveAffinePoint_over_base (n : β„•) (i : Fin (n + 1))
    (a : {j : Fin (n + 1) // j β‰  i} β†’ β„‚) :
    projectiveAffinePoint n i a ≫ ProjectiveSpace.projectiveSpaceToBase n = πŸ™ ProjectiveSpace.complexBase := by
  rw [projectiveAffinePoint, Category.assoc, ProjectiveChart.projectiveAffineChartMap_over]
  have h : CommRingCat.ofHom (MvPolynomial.C : β„‚ β†’+* ProjectiveChartToPolynomial.projectiveChartPolynomial n i) ≫
      CommRingCat.ofHom (MvPolynomial.eval a) = πŸ™ (CommRingCat.of β„‚) := by
    ext c
    simp
  rw [ProjectiveChart.projectiveChartPolynomialToBase, ← Spec.map_comp, h, Spec.map_id]

/-- Evaluation of the homogeneous fraction used to test a projective basic open. -/
theorem projectiveChartToPolynomial_isLocalizationElem (n : β„•) (i : Fin (n + 1))
    (f : ProjectiveSpace.homogeneousCoordinateRing n) (d : β„•) (hf : f ∈ ProjectiveSpace.projectiveGrading n d) :
    ProjectiveChartToPolynomial.projectiveChartToPolynomial n i
      (HomogeneousLocalization.Away.isLocalizationElem
        (ProjectiveChartToPolynomial.projectiveVariable_homogeneous n i) hf) = DehomogenizationC.Algebraic.Dehomogenization.dehomogenize i f := by
  simp only [HomogeneousLocalization.Away.isLocalizationElem,
    ProjectiveChartToPolynomial.projectiveChartToPolynomial_mk, pow_one]

/-- Projective basic opens pull back under an affine chart point according to
ordinary evaluation on the normalized homogeneous coordinate vector. -/
theorem projectiveAffinePoint_preimage_basicOpen (n : β„•) (i : Fin (n + 1))
    (a : {j : Fin (n + 1) // j β‰  i} β†’ β„‚)
    (f : ProjectiveSpace.homogeneousCoordinateRing n) (d : β„•) (hd : 0 < d)
    (hf : f ∈ ProjectiveSpace.projectiveGrading n d) :
    projectiveAffinePoint n i a ⁻¹ᡁ Proj.basicOpen (ProjectiveSpace.projectiveGrading n) f =
      PrimeSpectrum.basicOpen (MvPolynomial.eval (DehomogenizationC.Algebraic.Dehomogenization.insertOne i a) f) := by
  rw [projectiveAffinePoint, ProjectiveChart.projectiveAffineChartMap, ProjectiveChart.projectiveCoordinateIsoSpec_inv_ΞΉ]
  rw [Scheme.Hom.comp_preimage, Scheme.Hom.comp_preimage,
    Proj.awayΞΉ_preimage_basicOpen (π’œ := ProjectiveSpace.projectiveGrading n)
      (ProjectiveChartToPolynomial.projectiveVariable_homogeneous n i) (by decide : 0 < 1) hf hd,
    SpecMap_preimage_basicOpen, SpecMap_preimage_basicOpen]
  change PrimeSpectrum.basicOpen
    (MvPolynomial.eval a (ProjectiveChartToPolynomial.projectiveChartToPolynomial n i
      (HomogeneousLocalization.Away.isLocalizationElem
        (ProjectiveChartToPolynomial.projectiveVariable_homogeneous n i) hf))) = _
  rw [projectiveChartToPolynomial_isLocalizationElem n i f d hf, DehomogenizationC.Algebraic.Dehomogenization.eval_dehomogenize]

/-- Homogeneous equations of an evaluated affine chart point, in every degree. -/
theorem projectiveAffinePoint_homogeneous_mem_iff (n : β„•) (i : Fin (n + 1))
    (a : {j : Fin (n + 1) // j β‰  i} β†’ β„‚)
    (f : ProjectiveSpace.homogeneousCoordinateRing n) (d : β„•) (hf : f ∈ ProjectiveSpace.projectiveGrading n d)
    (x : ProjectiveSpace.complexBase) :
    f ∈ (projectiveAffinePoint n i a x).asHomogeneousIdeal ↔
      MvPolynomial.eval (DehomogenizationC.Algebraic.Dehomogenization.insertOne i a) f = 0 := by
  cases d with
  | zero =>
      obtain ⟨c, rfl⟩ : βˆƒ c : β„‚, f = MvPolynomial.C c :=
        ⟨_, HomogeneousEvalMap.eq_C_of_isHomogeneous_zero hf⟩
      simp only [MvPolynomial.eval_C]
      constructor
      Β· intro h
        by_contra hc
        let : (projectiveAffinePoint n i a x).asHomogeneousIdeal.toIdeal.IsPrime :=
          (projectiveAffinePoint n i a x).isPrime
        exact Ideal.notMem_of_isUnit
          (projectiveAffinePoint n i a x).asHomogeneousIdeal.toIdeal
          ((isUnit_iff_ne_zero.mpr hc).map MvPolynomial.C) h
      Β· intro hc
        simp [hc]
  | succ d =>
      have h : projectiveAffinePoint n i a x ∈ Proj.basicOpen (ProjectiveSpace.projectiveGrading n) f ↔
          MvPolynomial.eval (DehomogenizationC.Algebraic.Dehomogenization.insertOne i a) f β‰  0 := by
        change x ∈ projectiveAffinePoint n i a ⁻¹ᡁ Proj.basicOpen (ProjectiveSpace.projectiveGrading n) f ↔ _
        rw [projectiveAffinePoint_preimage_basicOpen n i a f (d + 1) (Nat.succ_pos d) hf]
        rw [Subsingleton.elim x (default : ProjectiveSpace.complexBase)]
        change MvPolynomial.eval (DehomogenizationC.Algebraic.Dehomogenization.insertOne i a) f βˆ‰ (default : ProjectiveSpace.complexBase).asIdeal ↔ _
        rw [Scheme.default_asIdeal]
        rfl
      change (Β¬ f ∈ (projectiveAffinePoint n i a x).asHomogeneousIdeal ↔
        Β¬ MvPolynomial.eval (DehomogenizationC.Algebraic.Dehomogenization.insertOne i a) f = 0) at h
      exact not_iff_not.mp h

/-- The normalized homogeneous vector associated to affine coordinates is nonzero. -/
theorem insertOne_ne_zero (n : β„•) (i : Fin (n + 1))
    (a : {j : Fin (n + 1) // j β‰  i} β†’ β„‚) : DehomogenizationC.Algebraic.Dehomogenization.insertOne i a β‰  0 := by
  intro h
  have : (1 : β„‚) = 0 := by simpa using congrFun h i
  exact one_ne_zero this

/-- The actual inverse affine-chart morphism agrees with the vector-point
construction on normalized coordinates. -/
theorem projectiveAffineChartMap_eval_eq_vectorPoint (n : β„•) (i : Fin (n + 1))
    (a : {j : Fin (n + 1) // j β‰  i} β†’ β„‚) (hv : DehomogenizationC.Algebraic.Dehomogenization.insertOne i a β‰  0) :
    Spec.map (CommRingCat.ofHom (MvPolynomial.eval a)) ≫ ProjectiveChart.projectiveAffineChartMap n i =
      ProjectiveVectorPoint.projectiveVectorPoint (DehomogenizationC.Algebraic.Dehomogenization.insertOne i a) hv := by
  change projectiveAffinePoint n i a = _
  apply ext_of_apply_closedPoint_eq (ProjectiveSpace.projectiveSpaceToBase n)
    (projectiveAffinePoint_over_base n i a) (ProjectiveVectorPoint.projectiveVectorPoint_over_base (DehomogenizationC.Algebraic.Dehomogenization.insertOne i a) hv)
  apply ProjectiveSpectrum.ext
  apply HomogeneousIdeal.ext'
  intro d f hf
  exact (projectiveAffinePoint_homogeneous_mem_iff n i a f d hf
    (IsLocalRing.closedPoint β„‚)).trans
      (ProjectiveVectorScale.projectiveVectorPoint_homogeneous_mem_iff (DehomogenizationC.Algebraic.Dehomogenization.insertOne i a) hv f d hf
        (IsLocalRing.closedPoint β„‚)).symm

end

end OAI.AlgebraicGeometry.Foundations.Scheme.ProjectiveChartPoint