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
|