/- 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