File size: 10,546 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
/-
Copyright 2026 The Formal Conjectures Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    https://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
This file has been modified.
-/
import OAI.AlgebraicTopology.LocalHomology.ChartFundamentalClass
import OAI.AlgebraicGeometry.Cycle.ComponentNormalCoordinates
import OAI.AlgebraicGeometry.ComplexPoint.ProjectiveHausdorff
import OAI.AlgebraicTopology.LocalHomology.ChartFundamentalClassGenerator
import OAI.AlgebraicTopology.LocalHomology.FundamentalClassGenerator
import OAI.AlgebraicTopology.LocalHomology.PuncturedEuclidean

/-! # Component Local Generator -/

namespace OAI.AlgebraicGeometry.Cycle

noncomputable section

open _root_.AlgebraicGeometry

/-!
# Local generators from exact cycle-component coordinates

An exact étale coordinate package on the smooth locus of a cycle component gives an
analytic chart on its chosen affine neighborhood. This file constructs that chart directly from
the retained polynomial-ring homomorphism. It then transports the standard complex local
homology generator through the chart.

The chart map factors through its open target and the point-neighborhood excision theorem.
Consequently the resulting class generates the full local homology of the affine component
neighborhood. This file does not construct a supported cohomology class or prove purity for the
component inside the ambient variety.
-/

open _root_.CategoryTheory _root_.Topology

section

attribute [local instance] AlgebraicGeometry.Over.Basic.overSpecAlgebra

variable {d n : ℕ} {X : Over (Spec ↧ℂ)} [IsIntegral X.left]
  [Smooth X.hom] [Foundations.ProjectiveSpaceIs.IsProjective X.hom] {x : X.left}
  [SmoothOfRelativeDimension d X.hom]

variable (C : ComponentNormalCoordinates.CycleComponentSeparateLocalCoordinates X x d n)

/-- The complex structure map on the selected affine component neighborhood. -/
abbrev ComponentNormalCoordinates.CycleComponentSeparateLocalCoordinates.neighborhoodStructureMap :
    C.componentNeighborhood.toScheme ⟶ Spec ↧ℂ :=
  C.componentNeighborhood.ι ≫ (ComponentNormalCoordinates.CycleComponentSeparateLocalCoordinates.componentSmoothLocus X x).ι ≫ Support.cycleComponentι X.left x ≫ X.hom

/-- The retained exact component coordinates, transported to global sections of the affine
neighborhood itself. -/
def ComponentNormalCoordinates.CycleComponentSeparateLocalCoordinates.coordinateRingHomOnNeighborhood :
    MvPolynomial (Fin n) ℂ →+* Γ(C.componentNeighborhood.toScheme, ⊤) :=
  C.componentNeighborhood.topIso.inv.hom.comp C.componentCoordinateAlgHom.toRingHom

/-- The transported coordinate map is compatible with the neighborhood's complex structure
map. -/
lemma ComponentNormalCoordinates.CycleComponentSeparateLocalCoordinates.C_comp_coordinateRingHomOnNeighborhood :
    CommRingCat.ofHom MvPolynomial.C ≫
        CommRingCat.ofHom C.coordinateRingHomOnNeighborhood =
      (Scheme.ΓSpecIso ↧ℂ).inv ≫ C.neighborhoodStructureMap.appTop := by
  apply (cancel_mono C.componentNeighborhood.topIso.hom).mp
  change (((CommRingCat.ofHom MvPolynomial.C) ≫
      CommRingCat.ofHom C.componentCoordinateAlgHom.toRingHom) ≫
        C.componentNeighborhood.topIso.inv) ≫
          C.componentNeighborhood.topIso.hom =
    (((Scheme.ΓSpecIso ↧ℂ).inv ≫
      C.neighborhoodStructureMap.appTop) ≫
        C.componentNeighborhood.topIso.hom)
  rw [Category.assoc, Iso.inv_hom_id, Category.comp_id]
  simp only [ComponentNormalCoordinates.CycleComponentSeparateLocalCoordinates.neighborhoodStructureMap, Scheme.Hom.comp_appTop, Category.assoc]
  rw [ComplexPoint.SmoothCoordinates.Scheme.Opens.ι_appTop_topIso_hom]
  exact congrArg CommRingCat.ofHom C.componentCoordinateAlgHom.comp_algebraMap

/-- The transported exact coordinate map remains étale. -/
lemma ComponentNormalCoordinates.CycleComponentSeparateLocalCoordinates.coordinateRingHomOnNeighborhood_etale :
    C.coordinateRingHomOnNeighborhood.Etale :=
  RingHom.Etale.respectsIso.1 C.componentCoordinateAlgHom.toRingHom
    C.componentNeighborhood.topIso.symm.commRingCatIsoToRingEquiv
      C.componentCoordinateAlgHom_etale

/-- Complex affine `n`-space is standard smooth of relative dimension `n`, using its presentation
with `n` variables and no relations. -/
lemma ComponentNormalCoordinates.CycleComponentSeparateLocalCoordinates.mvPolynomial_C_isStandardSmoothOfRelativeDimension :
    (MvPolynomial.C : ℂ →+* MvPolynomial (Fin n) ℂ).IsStandardSmoothOfRelativeDimension n := by
  rw [show (MvPolynomial.C : ℂ →+* MvPolynomial (Fin n) ℂ) =
    algebraMap ℂ (MvPolynomial (Fin n) ℂ) from rfl]
  rw [RingHom.isStandardSmoothOfRelativeDimension_algebraMap]
  let P : Algebra.SubmersivePresentation ℂ (MvPolynomial (Fin n) ℂ)
      (Fin n) Empty :=
    { toPreSubmersivePresentation :=
        { toPresentation :=
            { toGenerators := Algebra.Generators.mvPolynomial ℂ (Fin n)
              relation := Empty.elim
              span_range_relation_eq_ker := by
                rw [Algebra.Generators.ker_mvPolynomial]
                simp }
          map := Empty.elim
          map_inj := fun a ↦ a.elim }
      jacobian_isUnit := by
        rw [Algebra.PreSubmersivePresentation.jacobian_eq_jacobiMatrix_det,
          Matrix.det_isEmpty]
        simpa only [map_one] using
          (isUnit_one : IsUnit (1 : MvPolynomial (Fin n) ℂ)) }
  exact P.isStandardSmoothOfRelativeDimension (by
    simp [Algebra.Presentation.dimension])

/-- The structure map of the exact affine component neighborhood is standard smooth of the
coordinate package's specified dimension on global sections. -/
lemma ComponentNormalCoordinates.CycleComponentSeparateLocalCoordinates.neighborhoodStructureMap_appTop_isStandardSmoothOfRelativeDimension :
    C.neighborhoodStructureMap.appTop.hom.IsStandardSmoothOfRelativeDimension n := by
  have hcoord0 : C.coordinateRingHomOnNeighborhood.IsStandardSmoothOfRelativeDimension 0 :=
    RingHom.etale_iff_isStandardSmoothOfRelativeDimension_zero.mp
      C.coordinateRingHomOnNeighborhood_etale
  have hcomposite :
      RingHom.IsStandardSmoothOfRelativeDimension n
        (C.coordinateRingHomOnNeighborhood.comp MvPolynomial.C) := by
    simpa only [zero_add] using
      hcoord0.comp (ComponentNormalCoordinates.CycleComponentSeparateLocalCoordinates.mvPolynomial_C_isStandardSmoothOfRelativeDimension (n := n))
  have hcat := C.C_comp_coordinateRingHomOnNeighborhood
  have hcomp :
      RingHom.IsStandardSmoothOfRelativeDimension n
        (C.neighborhoodStructureMap.appTop.hom.comp
          (Scheme.ΓSpecIso ↧ℂ).inv.hom) := by
    have hring := congrArg CommRingCat.Hom.hom hcat
    change C.coordinateRingHomOnNeighborhood.comp MvPolynomial.C =
      C.neighborhoodStructureMap.appTop.hom.comp
        (Scheme.ΓSpecIso ↧ℂ).inv.hom at hring
    rw [← hring]
    exact hcomposite
  have h := hcomp.comp
    (RingHom.IsStandardSmoothOfRelativeDimension.equiv
      (Scheme.ΓSpecIso ↧ℂ).commRingCatIsoToRingEquiv)
  have heq :
      (C.neighborhoodStructureMap.appTop.hom.comp
        (Scheme.ΓSpecIso ↧ℂ).inv.hom).comp
          (Scheme.ΓSpecIso ↧ℂ).hom.hom =
        C.neighborhoodStructureMap.appTop.hom := by
    ext a
    have ha := ConcreteCategory.congr_hom
      (Scheme.ΓSpecIso ↧ℂ).hom_inv_id a
    exact congrArg C.neighborhoodStructureMap.appTop.hom ha
  exact heq ▸ h

/-- The exact coordinates prove that the selected affine component neighborhood is smooth of the
specified relative dimension. -/
noncomputable instance ComponentNormalCoordinates.CycleComponentSeparateLocalCoordinates.neighborhoodSmoothOfRelativeDimension :
    SmoothOfRelativeDimension n C.neighborhoodStructureMap where
  exists_isStandardSmoothOfRelativeDimension y := by
    let : IsAffine C.componentNeighborhood.toScheme :=
      C.componentNeighborhood_isAffine
    refine ⟨⊤, isAffineOpen_top _, C.neighborhoodStructureMap ⁻¹ᵁ ⊤,
      ?_, by simp, le_rfl, ?_⟩
    · simpa using (isAffineOpen_top C.componentNeighborhood.toScheme)
    · rw [Scheme.Hom.appLE_eq_app]
      exact C.neighborhoodStructureMap_appTop_isStandardSmoothOfRelativeDimension

noncomputable local instance ComponentNormalCoordinates.CycleComponentSeparateLocalCoordinates.coordinateRingAlgebra :
    Algebra (MvPolynomial (Fin n) ℂ) Γ(C.componentNeighborhood.toScheme, ⊤) :=
  C.coordinateRingHomOnNeighborhood.toAlgebra

noncomputable local instance ComponentNormalCoordinates.CycleComponentSeparateLocalCoordinates.coordinateRingComplexAlgebra :
    Algebra ℂ Γ(C.componentNeighborhood.toScheme, ⊤) :=
  (C.coordinateRingHomOnNeighborhood.comp MvPolynomial.C).toAlgebra

noncomputable local instance ComponentNormalCoordinates.CycleComponentSeparateLocalCoordinates.coordinateRingScalarTower :
    IsScalarTower ℂ (MvPolynomial (Fin n) ℂ)
      Γ(C.componentNeighborhood.toScheme, ⊤) :=
  IsScalarTower.of_algebraMap_eq fun _ ↦ rfl

noncomputable local instance ComponentNormalCoordinates.CycleComponentSeparateLocalCoordinates.coordinateRingEtale :
    Algebra.Etale (MvPolynomial (Fin n) ℂ)
      Γ(C.componentNeighborhood.toScheme, ⊤) :=
  RingHom.etale_algebraMap.mp C.coordinateRingHomOnNeighborhood_etale

end

open OAI.AlgebraicTopology
open OAI.AlgebraicTopology.Singular

/-- The oriented standard complex local class generates rational local homology in every complex
dimension. -/
lemma ComponentLocalGenerator.span_standardComplexLocalClass_eq_top (n : ℕ) :
    Submodule.span ℚ {AlgebraicTopology.LocalHomology.ComplexClass.Singular.standardComplexLocalClass ℚ n} = ⊤ := by
  cases n with
  | zero => exact AlgebraicTopology.LocalHomology.FundamentalClassGenerator.Singular.span_standardComplexLocalClass_zero_eq_top
  | succ n =>
      rw [AlgebraicTopology.LocalHomology.FundamentalClassGenerator.Singular.span_standardComplexLocalClass_eq_top_iff]
      have hdeg : (n + 1) * 2 = n * 2 + 2 := by lia
      rw [hdeg]
      exact AlgebraicTopology.LocalHomology.PuncturedEuclidean.Singular.span_standardLocalClass_add_two_eq_top (n * 2)

end

end OAI.AlgebraicGeometry.Cycle