| import Mathlib |
| import OAI.AlgebraicGeometry.NumericalDimension.CompleteIntersections |
|
|
| namespace OAI |
|
|
| /-! Open Sections. -/ |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace |
| open AlgebraicGeometry CategoryTheory Limits |
| open AlgebraicGeometry CategoryTheory TopologicalSpace Limits |
| open Algebra KaehlerDifferential IsLocalRing TensorProduct |
| open AlgebraicGeometry CategoryTheory TensorProduct |
| open TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace Set Topology |
| open AlgebraicGeometry TopologicalSpace |
| open AlgebraicGeometry CategoryTheory HomogeneousLocalization |
|
|
| namespace NumericalDimensionOne |
| attribute [local instance] MvPolynomial.gradedAlgebra |
|
|
| theorem hyperplane_intersection_component_dimension_lower |
| {X S : Scheme} [IsLocallyNoetherian X] [NoetherianSpace S] [JacobsonSpace S] |
| {N d r : ℕ} (f : X ⟶ complexProjectiveSpace N) [IsClosedImmersion f] |
| (i : S ⟶ X) [IsClosedImmersion i] (a : Fin r → Fin (N+1) → ℂ) |
| (hs : Set.range i = {x | ∀ j, f x ∉ |
| Proj.basicOpen (MvPolynomial.homogeneousSubmodule (Fin (N+1)) ℂ) |
| (projectiveLinearPolynomial (a j))}) |
| (hd : ∀ x : X, IsClosed {x} → (d+r : ℕ) ≤ Order.coheight x) |
| {Z : Set S} (hZ : Z ∈ irreducibleComponents S) : |
| (d : WithBot ℕ∞) ≤ topologicalKrullDim Z := by |
| obtain ⟨p,hpc,_,hpZ⟩ := exists_closed_point_in_component_interior S hZ |
| have hpic : IsClosed {i p} := by |
| simpa only [Set.image_singleton] using i.isClosedEmbedding.isClosedMap {p} hpc |
| have hp : ∀ j, f (i p) ∉ |
| Proj.basicOpen (MvPolynomial.homogeneousSubmodule (Fin (N+1)) ℂ) |
| (projectiveLinearPolynomial (a j)) := by |
| have h : i p ∈ Set.range i := Set.mem_range_self p |
| rw [hs] at h |
| exact h |
| obtain ⟨q,hpq,hqd,hqa⟩ := projective_section_dimension_lower f (i p) a hp (hd _ hpic) |
| have hqr : q ∈ Set.range i := by rwa [hs] |
| obtain ⟨y,hyq⟩ := hqr |
| have hpy : p ≤ y := by |
| apply i.isClosedEmbedding.isEmbedding.isInducing.specializes_iff.mp |
| rw [hyq] |
| exact hpq |
| have hdy : (d : ℕ∞) ≤ Order.height y := by |
| rwa [height_eq_of_closedImmersion i y,hyq] |
| exact (WithBot.coe_le_coe.mpr hdy).trans |
| (height_le_closed_topologicalKrullDim (isClosed_of_mem_irreducibleComponents Z hZ) |
| ⟨y,hpZ y hpy⟩) |
| end NumericalDimensionOne |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace |
| open AlgebraicGeometry CategoryTheory Limits |
| open AlgebraicGeometry CategoryTheory TopologicalSpace Limits |
| open Algebra KaehlerDifferential IsLocalRing TensorProduct |
| open AlgebraicGeometry CategoryTheory TensorProduct |
| open TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace Set Topology |
| open AlgebraicGeometry TopologicalSpace |
| open AlgebraicGeometry CategoryTheory HomogeneousLocalization |
|
|
| namespace NumericalDimensionOne |
| noncomputable section |
| attribute [local instance] MvPolynomial.gradedAlgebra |
|
|
| theorem IncidenceCutChain.pure_dimension_of_embedding |
| {X S : Scheme} [IsIntegral X] [IsLocallyNoetherian X] |
| {N d r : ℕ} {D : WeilDivisor X} {s : Fin (N+1) → X.functionField} |
| (A : DivisorAffineAtlas X D s) (sX : X ⟶ Spec (.of ℂ)) [IsProper sX] |
| (J : 𝔸(Fin (N+1);X).IdealSheafData) |
| (hJ : ∀ j, J.comap (AffineSpace.map _ (A.cover.f j)) = |
| Scheme.IdealSheafData.ofIdealTop (Ideal.span {universalLinearSection (A.coordinate j)})) |
| (f : X ⟶ complexProjectiveSpace N) [IsClosedImmersion f] |
| (hf : ∀ j, (A.chart j).domain.ι ≫ f = (A.chart j).toMorphism sX) |
| {i : S ⟶ X} (h : IncidenceCutChain X sX J r S i) |
| (hdim : topologicalKrullDim X = (d+r : ℕ)) : |
| Nonempty S ∧ topologicalKrullDim S = d ∧ |
| ∀ Z ∈ irreducibleComponents S, topologicalKrullDim Z = d := by |
| have := h.isClosedImmersion |
| have : IsProper (i ≫ sX) := inferInstance |
| have : IsLocallyNoetherian S := LocallyOfFiniteType.isLocallyNoetherian (i ≫ sX) |
| have : CompactSpace S := QuasiCompact.compactSpace_of_compactSpace (i ≫ sX) |
| have : IsNoetherian S := ⟨⟩ |
| have : JacobsonSpace S := LocallyOfFiniteType.jacobsonSpace (i ≫ sX) |
| have hdq : (d+r : ℕ) ≤ Order.height (genericPoint X) := by |
| have he := (genericPoint_height_eq_dimension X).trans hdim |
| exact_mod_cast le_of_eq he.symm |
| obtain ⟨x,hxd⟩ := h.exists_height_ge_of_embedding A sX J hJ f hf (genericPoint X) hdq |
| have hu := h.height_le (fun q => by |
| have he := Order.height_le_krullDim q |
| rw [← scheme_topologicalKrullDim_eq,hdim] at he |
| exact_mod_cast he) |
| have hS : topologicalKrullDim S = d := by |
| rw [scheme_topologicalKrullDim_eq] |
| apply le_antisymm |
| · rw [Order.krullDim_eq_iSup_height] |
| exact iSup_le (fun q => WithBot.coe_le_coe.mpr (hu q)) |
| · exact (WithBot.coe_le_coe.mpr hxd).trans (Order.height_le_krullDim x) |
| refine ⟨⟨x⟩,hS,?_⟩ |
| obtain ⟨ps,hps,_,hker⟩ := h.exists_parameters |
| have hrange : Set.range i = {x | ∀ j : Fin ps.length, f x ∉ |
| Proj.basicOpen (MvPolynomial.homogeneousSubmodule (Fin (N+1)) ℂ) |
| (projectiveLinearPolynomial (parameterCoefficient (ps.get j)))} := by |
| rw [← i.isClosedEmbedding.isClosed_range.closure_eq,← Scheme.Hom.support_ker,hker] |
| ext x |
| refine (incidenceIntersectionIdeal_mem_support sX J ps x).trans ?_ |
| constructor |
| · intro hx j |
| have hm := hx (ps.get j) (List.get_mem ps j) |
| change x ∈ ((J.comap (parameterSection sX (ps.get j))).support : Set X) at hm |
| rwa [A.incidence_member_support sX J hJ f hf] at hm |
| · intro hx p hp |
| obtain ⟨j,rfl⟩ := List.mem_iff_get.mp hp |
| change x ∈ ((J.comap (parameterSection sX (ps.get j))).support : Set X) |
| rw [A.incidence_member_support sX J hJ f hf] |
| exact hx j |
| have hff := functionField_dimension_of_dimension sX (d+r) hdim |
| obtain ⟨_,hclosed,_⟩ := scheme_dimension_of_functionField ℂ sX (d+r) hff |
| intro Z hZ |
| apply le_antisymm |
| · exact (topologicalKrullDim_subspace_le S Z).trans hS.le |
| · apply hyperplane_intersection_component_dimension_lower f i |
| (fun j => parameterCoefficient (ps.get j)) hrange _ hZ |
| intro q hq |
| rw [hclosed q hq,hps] |
| end |
| end NumericalDimensionOne |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace |
| open AlgebraicGeometry CategoryTheory Limits |
| open AlgebraicGeometry CategoryTheory TopologicalSpace Limits |
| open Algebra KaehlerDifferential IsLocalRing TensorProduct |
| open AlgebraicGeometry CategoryTheory TensorProduct |
| open TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace Set Topology |
| open AlgebraicGeometry TopologicalSpace |
| open AlgebraicGeometry CategoryTheory HomogeneousLocalization |
|
|
| namespace NumericalDimensionOne |
| noncomputable section |
|
|
| theorem exists_smooth_pure_very_ample_complete_intersection |
| {X : Scheme} [IsIntegral X] [IsLocallyNoetherian X] |
| {N d r : ℕ} {D : WeilDivisor X} {s : Fin (N+1) → X.functionField} |
| (A : DivisorAffineAtlas X D s) (hs : ∀ j, s j ≠ 0) |
| (sX : X ⟶ Spec (.of ℂ)) [IsProper sX] |
| (f : X ⟶ complexProjectiveSpace N) [IsClosedImmersion f] |
| (hf : ∀ j, (A.chart j).domain.ι ≫ f = (A.chart j).toMorphism sX) |
| (hover : f ≫ complexProjectiveSpaceMap N = sX) |
| (hdim : topologicalKrullDim X = (d+r : ℕ)) (U : X.Opens) |
| [Smooth (U.ι ≫ sX)] {ι : Type} [Countable ι] |
| (Z : ι → Set X) (hZ : ∀ j, IsClosed (Z j)) |
| (hdU : topologicalKrullDim ↥((U : Set X)ᶜ) < r) |
| (hdZ : ∀ j, topologicalKrullDim (Z j) < r) : |
| ∃ (J : 𝔸(Fin (N+1);X).IdealSheafData) (S : Scheme) (i : S ⟶ X), |
| (∀ a, J.comap (AffineSpace.map _ (A.cover.f a)) = |
| Scheme.IdealSheafData.ofIdealTop (Ideal.span {universalLinearSection (A.coordinate a)})) ∧ |
| IncidenceCutChain X sX J r S i ∧ Smooth (i ≫ sX) ∧ |
| Nonempty S ∧ topologicalKrullDim S = d ∧ |
| (∀ T ∈ irreducibleComponents S, topologicalKrullDim T = d) ∧ |
| IsComplexProjective (i ≫ sX) ∧ Set.range i ⊆ U ∧ ∀ j x, i x ∉ Z j |
| := by |
| classical |
| have : CompactSpace X := QuasiCompact.compactSpace_of_compactSpace sX |
| have : IsNoetherian X := ⟨⟩ |
| have : Uncountable ℂ := Cardinal.aleph0_lt_mk_iff.mp (by |
| rw [Cardinal.mk_complex] |
| exact Cardinal.aleph0_lt_continuum) |
| obtain ⟨J,hJ⟩ := A.incidence_exists hs |
| let T : Option ι → Set X := fun a => a.elim ((U : Set X)ᶜ) Z |
| have hT : ∀ a, IsClosed (T a) := by |
| intro a |
| rcases a with _ | a |
| · exact U.isOpen.isClosed_compl |
| · exact hZ a |
| have hdT : ∀ a x, x ∈ T a → Order.height x < r := by |
| intro a |
| rcases a with _ | a |
| · exact height_lt_of_closed_dim_lt U.isOpen.isClosed_compl hdU |
| · exact height_lt_of_closed_dim_lt (hZ a) (hdZ a) |
| obtain ⟨S,i,hchain,hsm,ha⟩ := exists_smooth_complete_intersection_avoiding r sX U |
| A.cover A.coordinate |
| (fun a => ⟨(A.chart a).unit_index,by simp [DivisorAffineAtlas.coordinate, |
| DivisorProjectiveChart.normalized_index]; rfl⟩) J hJ T hT |
| (height_lt_of_closed_dim_lt U.isOpen.isClosed_compl hdU) hdT |
| obtain ⟨hne,hd,hpure⟩ := hchain.pure_dimension_of_embedding A sX J hJ f hf hdim |
| have := hchain.isClosedImmersion |
| refine ⟨J,S,i,hJ,hchain,hsm,hne,hd,hpure,?_,?_,?_⟩ |
| · exact ⟨N,i ≫ f,inferInstance,by simp only [Category.assoc,hover]⟩ |
| · rintro _ ⟨x,rfl⟩ |
| exact Classical.not_not.mp (ha none x) |
| · intro j |
| exact ha (some j) |
| end |
| end NumericalDimensionOne |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace |
| open AlgebraicGeometry CategoryTheory Limits |
| open AlgebraicGeometry CategoryTheory TopologicalSpace Limits |
| open Algebra KaehlerDifferential IsLocalRing TensorProduct |
| open AlgebraicGeometry CategoryTheory TensorProduct |
| open TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace Set Topology |
| open AlgebraicGeometry TopologicalSpace |
| open AlgebraicGeometry CategoryTheory HomogeneousLocalization |
| open scoped IntermediateField.algebraAdjoinAdjoin |
|
|
| namespace NumericalDimensionOne |
|
|
| theorem nonempty_differential_basis_of_transcendence_basis |
| {k K ι : Type} [Field k] [Field K] [Algebra k K] [CharZero k] |
| {v : ι → K} (hv : IsTranscendenceBasis k v) : |
| Nonempty (Module.Basis ι K Ω[K⁄k]) := by |
| let A := Algebra.adjoin k (Set.range v) |
| let F := IntermediateField.adjoin k (Set.range v) |
| let e : MvPolynomial ι k ≃ₐ[k] A := hv.1.aevalEquiv |
| let : Algebra (MvPolynomial ι k) A := e.toRingHom.toAlgebra |
| have : IsScalarTower k (MvPolynomial ι k) A := IsScalarTower.of_algHom e.toAlgHom |
| let e' : MvPolynomial ι k ≃ₐ[MvPolynomial ι k] A := |
| { e.toRingEquiv with commutes' := fun _ => rfl } |
| have : Algebra.FormallyEtale (MvPolynomial ι k) A := Algebra.FormallyEtale.of_equiv e' |
| let bA := (KaehlerDifferential.isBaseChange_of_formallyEtale k (MvPolynomial ι k) A).basis |
| (KaehlerDifferential.mvPolynomialBasis k ι) |
| have : Algebra.FormallyEtale A F := Algebra.FormallyEtale.of_isLocalization (nonZeroDivisors A) |
| let bF := (KaehlerDifferential.isBaseChange_of_formallyEtale k A F).basis bA |
| have : Algebra.IsAlgebraic A K := hv.isAlgebraic |
| have : Algebra.IsAlgebraic F K := Algebra.IsAlgebraic.extendScalars |
| (IsFractionRing.injective A F) |
| have : Algebra.FormallyEtale F K := Algebra.FormallyEtale.of_isSeparable F K |
| exact ⟨(KaehlerDifferential.isBaseChange_of_formallyEtale k F K).basis bF⟩ |
| end NumericalDimensionOne |
| |
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace |
| open AlgebraicGeometry CategoryTheory Limits |
| open AlgebraicGeometry CategoryTheory TopologicalSpace Limits |
| open Algebra KaehlerDifferential IsLocalRing TensorProduct |
| open AlgebraicGeometry CategoryTheory TensorProduct |
| open TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace Set Topology |
| open AlgebraicGeometry TopologicalSpace |
| open AlgebraicGeometry CategoryTheory HomogeneousLocalization |
| open scoped IntermediateField.algebraAdjoinAdjoin |
| |
| namespace NumericalDimensionOne |
| |
| theorem differential_rank_eq_trdeg (k K : Type) [Field k] [Field K] |
| [Algebra k K] [CharZero k] : Module.rank K Ω[K⁄k] = Algebra.trdeg k K := by |
| obtain ⟨v,hv⟩ := exists_isTranscendenceBasis k K |
| obtain ⟨b⟩ := nonempty_differential_basis_of_transcendence_basis hv |
| exact b.mk_eq_rank''.symm.trans hv.cardinalMk_eq_trdeg |
| |
| theorem standardSmoothOfRelativeDimension_of_fractionField |
| (k A K : Type) [Field k] [CommRing A] [IsDomain A] [Field K] [CharZero k] |
| [Algebra k A] [Algebra k K] [Algebra A K] [IsScalarTower k A K] |
| [IsFractionRing A K] [Algebra.IsStandardSmooth k A] |
| (n : ℕ) (hd : Algebra.trdeg k K = n) : |
| Algebra.IsStandardSmoothOfRelativeDimension n k A := by |
| apply (Algebra.IsStandardSmoothOfRelativeDimension.iff_of_isStandardSmooth n).mpr |
| have : Algebra.FormallyEtale A K := Algebra.FormallyEtale.of_isLocalization (nonZeroDivisors A) |
| let b := Module.Free.chooseBasis A Ω[A⁄k] |
| let bK := (KaehlerDifferential.isBaseChange_of_formallyEtale k A K).basis b |
| rw [← b.mk_eq_rank'', bK.mk_eq_rank'', differential_rank_eq_trdeg,hd] |
| end NumericalDimensionOne |
| |
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace |
| open AlgebraicGeometry CategoryTheory Limits |
| open AlgebraicGeometry CategoryTheory TopologicalSpace Limits |
| open Algebra KaehlerDifferential IsLocalRing TensorProduct |
| open AlgebraicGeometry CategoryTheory TensorProduct |
| open TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace Set Topology |
| open AlgebraicGeometry TopologicalSpace |
| open AlgebraicGeometry CategoryTheory HomogeneousLocalization |
| open scoped IntermediateField.algebraAdjoinAdjoin |
| |
| namespace NumericalDimensionOne |
| |
| theorem isReduced_of_etale_domain_base (R A : Type*) [CommRing R] [IsDomain R] |
| [CommRing A] [Algebra R A] [Algebra.Etale R A] : IsReduced A := by |
| let K := FractionRing R |
| have : Algebra.FormallyUnramified K (K ⊗[R] A) := inferInstance |
| have : IsReduced (K ⊗[R] A) := Algebra.FormallyUnramified.isReduced_of_field K (K ⊗[R] A) |
| let f := (Algebra.TensorProduct.includeRight (R := R) (A := K) (B := A)) |
| have hf : Function.Injective f := by |
| have he : ⇑f = (LinearMap.rTensor A (Algebra.ofId R K).toLinearMap).comp |
| (Algebra.TensorProduct.lid R A).symm.toLinearMap := by |
| ext a |
| simp [f] |
| rw [he] |
| exact (Module.Flat.rTensor_preserves_injective_linearMap _ |
| (IsFractionRing.injective R K)).comp (Algebra.TensorProduct.lid R A).symm.injective |
| exact isReduced_of_injective f hf |
| |
| theorem isReduced_of_smooth_field (k A : Type*) [Field k] [CommRing A] |
| [Algebra k A] [Algebra.Smooth k A] : IsReduced A := by |
| apply isReduced_ofLocalizationMaximal |
| intro p hp |
| let := hp |
| obtain ⟨f,hfp,n,af,ht,he⟩ := |
| Algebra.IsSmoothAt.exists_isStandardEtale_mvPolynomial (R := k) (p := p) |
| let : Algebra (MvPolynomial (Fin n) k) (Localization.Away f) := af |
| let : IsScalarTower k (MvPolynomial (Fin n) k) (Localization.Away f) := ht |
| let : Algebra.IsStandardEtale (MvPolynomial (Fin n) k) (Localization.Away f) := he |
| have : IsReduced (Localization.Away f) := |
| isReduced_of_etale_domain_base (MvPolynomial (Fin n) k) (Localization.Away f) |
| have hle : Submonoid.powers f ≤ p.primeCompl := Submonoid.powers_le.mpr hfp |
| let : Algebra (Localization.Away f) (Localization.AtPrime p) := |
| IsLocalization.localizationAlgebraOfSubmonoidLe _ _ _ _ hle |
| let : IsScalarTower A (Localization.Away f) (Localization.AtPrime p) := |
| IsLocalization.localization_isScalarTower_of_submonoid_le _ _ _ _ hle |
| let : IsLocalization (p.primeCompl.map (algebraMap A (Localization.Away f))) |
| (Localization.AtPrime p) := |
| IsLocalization.isLocalization_of_submonoid_le _ _ _ _ hle |
| exact isReduced_localizationPreserves |
| (p.primeCompl.map (algebraMap A (Localization.Away f))) (Localization.AtPrime p) inferInstance |
| end NumericalDimensionOne |
| |
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace |
| open AlgebraicGeometry CategoryTheory Limits |
| open AlgebraicGeometry CategoryTheory TopologicalSpace Limits |
| open Algebra KaehlerDifferential IsLocalRing TensorProduct |
| open AlgebraicGeometry CategoryTheory TensorProduct |
| open TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace Set Topology |
| open AlgebraicGeometry TopologicalSpace |
| open AlgebraicGeometry CategoryTheory HomogeneousLocalization |
| open scoped IntermediateField.algebraAdjoinAdjoin |
| |
| namespace NumericalDimensionOne |
| noncomputable section |
| |
| theorem scheme_isReduced_of_smooth_field |
| {k : Type} [Field k] {X : Scheme} (sX : X ⟶ Spec (.of k)) [Smooth sX] : |
| IsReduced X := by |
| apply +allowSynthFailures isReduced_of_isReduced_stalk |
| intro x |
| obtain ⟨U,hU,V,hV,hx,e,hsm⟩ := Smooth.exists_isStandardSmooth sX x |
| have hUtop : U = ⊤ := by |
| ext y |
| have hm : sX x ∈ U := e hx |
| rw [Subsingleton.elim (sX x) y] at hm |
| exact ⟨fun _ => trivial,fun _ => hm⟩ |
| subst U |
| let := schemeOpenAlgebra sX V |
| have hstd : RingHom.IsStandardSmooth (schemeOpenScalar sX V) := |
| RingHom.isStandardSmooth_respectsIso.right (sX.appLE ⊤ V e).hom |
| (Scheme.ΓSpecIso (.of k)).symm.commRingCatIsoToRingEquiv hsm |
| have : Algebra.IsStandardSmooth k Γ(X,V) := hstd |
| have : _root_.IsReduced Γ(X,V) := isReduced_of_smooth_field k Γ(X,V) |
| let y : V := ⟨x,hx⟩ |
| let := TopCat.Presheaf.algebra_section_stalk X.presheaf y |
| let := hV.isLocalization_stalk y |
| exact isReduced_localizationPreserves (hV.primeIdealOf y).asIdeal.primeCompl |
| (X.presheaf.stalk x) inferInstance |
| end |
| end NumericalDimensionOne |
| |
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace |
| open AlgebraicGeometry CategoryTheory Limits |
| open AlgebraicGeometry CategoryTheory TopologicalSpace Limits |
| open Algebra KaehlerDifferential IsLocalRing TensorProduct |
| open AlgebraicGeometry CategoryTheory TensorProduct |
| open TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace Set Topology |
| open AlgebraicGeometry TopologicalSpace |
| open AlgebraicGeometry CategoryTheory HomogeneousLocalization |
| open scoped IntermediateField.algebraAdjoinAdjoin |
| |
| namespace NumericalDimensionOne |
| noncomputable section |
| |
| lemma stalk_scalar_over |
| {X Y : Scheme} (k : CommRingCat) (sY : Y ⟶ Spec k) |
| (f : X ⟶ Y) (x : X) (a : k) : |
| f.stalkMap x (schemeStalkScalar k sY (f x) a) = |
| schemeStalkScalar k (f ≫ sY) x a := by |
| simp only [schemeStalkScalar, RingHom.coe_comp, Function.comp_apply, |
| Scheme.Hom.comp_appTop, CommRingCat.comp_apply] |
| simp only [Scheme.Hom.appTop] |
| exact f.germ_stalkMap_apply ⊤ x (by trivial) (sY.appTop ((Scheme.ΓSpecIso k).inv a)) |
| |
| lemma generic_component_stalk_isField {X : Scheme} [IsReduced X] (q : X) |
| (hq : closure ({q} : Set X) ∈ irreducibleComponents X) : |
| IsField (X.presheaf.stalk q) := by |
| exact isField_stalk_of_closure_mem_irreducibleComponents X q hq |
| end |
| end NumericalDimensionOne |
| |
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace |
| open AlgebraicGeometry CategoryTheory Limits |
| open AlgebraicGeometry CategoryTheory TopologicalSpace Limits |
| open Algebra KaehlerDifferential IsLocalRing TensorProduct |
| open AlgebraicGeometry CategoryTheory TensorProduct |
| open TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace Set Topology |
| open AlgebraicGeometry TopologicalSpace |
| open AlgebraicGeometry CategoryTheory HomogeneousLocalization |
| open scoped IntermediateField.algebraAdjoinAdjoin |
| |
| namespace NumericalDimensionOne |
| noncomputable section |
| |
| theorem generic_component_stalk_trdeg {k : Type} [Field k] {X : Scheme} [IsReduced X] |
| (sX : X ⟶ Spec (.of k)) [LocallyOfFiniteType sX] |
| (n : ℕ) (hpure : ∀ Z ∈ irreducibleComponents X, topologicalKrullDim Z = n) |
| (q : X) (hq : closure ({q} : Set X) ∈ irreducibleComponents X) : |
| let := schemeStalkAlgebra (.of k) sX q; |
| Algebra.trdeg k (X.presheaf.stalk q) = n := by |
| let C := pointClosure q |
| let f := pointClosureι q |
| let g := genericPoint C |
| let := schemeStalkAlgebra (.of k) sX (f g) |
| let := schemeFieldAlgebra (.of k) (f ≫ sX) |
| have hq' : closure ({f g} : Set X) ∈ irreducibleComponents X := by |
| simpa only [f,g,C,pointClosure_generic] using hq |
| have hfld := generic_component_stalk_isField (f g) hq' |
| let := hfld.toField |
| let e : (X.presheaf.stalk (f g)) ≃ₐ[k] C.functionField := |
| { RingEquiv.ofBijective (f.stalkMap g).hom |
| ⟨(f.stalkMap g).hom.injective,f.stalkMap_surjective g⟩ with |
| commutes' := fun a => stalk_scalar_over (.of k) sX f g a } |
| let eC := f.isClosedEmbedding.isEmbedding.toHomeomorph.trans |
| (Homeomorph.setCongr (pointClosure_range q)) |
| have hd : topologicalKrullDim C = n := |
| (eC.isHomeomorph.topologicalKrullDim_eq eC).trans (hpure _ hq) |
| have hh := e.trdeg_eq.trans (functionField_dimension_of_dimension (f ≫ sX) n hd) |
| change (let := schemeStalkAlgebra (.of k) sX (f g); |
| Algebra.trdeg k (X.presheaf.stalk (f g)) = n) at hh |
| dsimp only [f,g,C] at hh |
| rw [pointClosure_generic] at hh |
| exact hh |
| end |
| end NumericalDimensionOne |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace |
| open AlgebraicGeometry CategoryTheory Limits |
| open AlgebraicGeometry CategoryTheory TopologicalSpace Limits |
| open Algebra KaehlerDifferential IsLocalRing TensorProduct |
| open AlgebraicGeometry CategoryTheory TensorProduct |
| open TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace Set Topology |
| open AlgebraicGeometry TopologicalSpace |
| open AlgebraicGeometry CategoryTheory HomogeneousLocalization |
| open scoped IntermediateField.algebraAdjoinAdjoin |
|
|
| namespace NumericalDimensionOne |
| noncomputable section |
|
|
| theorem standardSmoothOfRelativeDimension_of_formallyEtaleField |
| (k A K : Type) [Field k] [CommRing A] [Nontrivial A] [Field K] [CharZero k] |
| [Algebra k A] [Algebra k K] [Algebra A K] [IsScalarTower k A K] |
| [Algebra.FormallyEtale A K] [Algebra.IsStandardSmooth k A] |
| (n : ℕ) (hd : Algebra.trdeg k K = n) : |
| Algebra.IsStandardSmoothOfRelativeDimension n k A := by |
| apply (Algebra.IsStandardSmoothOfRelativeDimension.iff_of_isStandardSmooth n).mpr |
| let b := Module.Free.chooseBasis A Ω[A⁄k] |
| let bK := (KaehlerDifferential.isBaseChange_of_formallyEtale k A K).basis b |
| rw [← b.mk_eq_rank'',bK.mk_eq_rank'',differential_rank_eq_trdeg,hd] |
|
|
| theorem smooth_relative_dimension_of_pure_dimension |
| {k : Type} [Field k] [CharZero k] {X : Scheme} |
| (sX : X ⟶ Spec (.of k)) [Smooth sX] |
| (n : ℕ) (hpure : ∀ Z ∈ irreducibleComponents X, topologicalKrullDim Z = n) : |
| SmoothOfRelativeDimension n sX := by |
| have : IsReduced X := scheme_isReduced_of_smooth_field sX |
| constructor |
| intro x |
| obtain ⟨U,hU,V,hV,hx,e,hsm⟩ := Smooth.exists_isStandardSmooth sX x |
| have hUtop : U = ⊤ := by |
| ext y |
| have hm : sX x ∈ U := e hx |
| rw [Subsingleton.elim (sX x) y] at hm |
| exact ⟨fun _ => trivial,fun _ => hm⟩ |
| subst U |
| have : Nonempty V := ⟨⟨x,hx⟩⟩ |
| let C : irreducibleComponents X := |
| ⟨irreducibleComponent x,irreducibleComponent_mem_irreducibleComponents x⟩ |
| let q : genericPoints X := genericPoints.ofComponent C |
| have hqV : q.1 ∈ V := |
| ((genericPoints.isGenericPoint_ofComponent C).specializes mem_irreducibleComponent).mem_open |
| V.isOpen hx |
| let y : V := ⟨q.1,hqV⟩ |
| let := schemeOpenAlgebra sX V |
| let := schemeStalkAlgebra (.of k) sX q.1 |
| let := TopCat.Presheaf.algebra_section_stalk X.presheaf y |
| have := open_stalk_scalar_tower sX V y |
| let := (generic_component_stalk_isField q.1 q.2).toField |
| have := hV.isLocalization_stalk y |
| have : Algebra.FormallyEtale Γ(X,V) (X.presheaf.stalk q.1) := |
| Algebra.FormallyEtale.of_isLocalization (hV.primeIdealOf y).asIdeal.primeCompl |
| have hstd : RingHom.IsStandardSmooth (schemeOpenScalar sX V) := |
| RingHom.isStandardSmooth_respectsIso.right (sX.appLE ⊤ V e).hom |
| (Scheme.ΓSpecIso (.of k)).symm.commRingCatIsoToRingEquiv hsm |
| have : Algebra.IsStandardSmooth k Γ(X,V) := hstd |
| have htrdeg : Algebra.trdeg k (X.presheaf.stalk q.1) = n := |
| generic_component_stalk_trdeg sX n hpure q.1 q.2 |
| have hrel : Algebra.IsStandardSmoothOfRelativeDimension n k Γ(X,V) := |
| standardSmoothOfRelativeDimension_of_formallyEtaleField k Γ(X,V) |
| (X.presheaf.stalk q.1) n htrdeg |
| have hr : RingHom.IsStandardSmoothOfRelativeDimension n (schemeOpenScalar sX V) := hrel |
| refine ⟨⊤,hU,V,hV,hx,e,?_⟩ |
| exact (RingHom.isStandardSmoothOfRelativeDimension_respectsIso (n := n)).cancel_left_isIso |
| (Scheme.ΓSpecIso (.of k)).inv (sX.appLE ⊤ V e) |>.mp hr |
| end |
| end NumericalDimensionOne |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace |
| open AlgebraicGeometry CategoryTheory Limits |
| open AlgebraicGeometry CategoryTheory TopologicalSpace Limits |
| open Algebra KaehlerDifferential IsLocalRing TensorProduct |
| open AlgebraicGeometry CategoryTheory TensorProduct |
| open TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace Set Topology |
| open AlgebraicGeometry TopologicalSpace |
| open AlgebraicGeometry CategoryTheory HomogeneousLocalization |
| open scoped IntermediateField.algebraAdjoinAdjoin |
|
|
| namespace NumericalDimensionOne |
| noncomputable section |
| lemma generated_finite_section_cover_on_open |
| {X : Scheme} [IsIntegral X] [IsLocallyNoetherian X] [CompactSpace X] |
| (D : WeilDivisor X) (U : X.Opens) (hU : Nonempty U) |
| (hgen : ∀ x : X, x ∈ U → IsGeneratedAt D x) : |
| ∃ N : ℕ, ∃ s : Fin (N+1) → X.functionField, |
| (∀ i, s i ≠ 0 ∧ IsDivisorSection D (s i)) ∧ |
| (∀ x : X, x ∈ U → ∃ i, x ∈ sectionNonvanishing D (s i)) := by |
| classical |
| choose s hs hsec hx using fun x : U => hgen x.1 x.2 |
| have : NoetherianSpace X := (show IsNoetherian X from ⟨⟩).noetherianSpace |
| obtain ⟨V,hV⟩ := (NoetherianSpace.isCompact (U : Set X)).elim_finite_subcover |
| (fun x : U => (sectionNonvanishing D (s x) : Set X)) |
| (fun x => (sectionNonvanishing D (s x)).isOpen) |
| (fun x h => Set.mem_iUnion.mpr ⟨⟨x,h⟩,hx ⟨x,h⟩⟩) |
| let e : Fin (V.card+1) ≃ Option V := |
| (Fintype.equivFinOfCardEq (by simp)).symm |
| let point : Option V → U := fun o => o.elim (Classical.choice hU) Subtype.val |
| refine ⟨V.card,fun i => s (point (e i)),fun i => ⟨hs _,hsec _⟩,?_⟩ |
| intro x hxU |
| obtain ⟨y,hy,hxy⟩ := Set.mem_iUnion₂.mp (hV hxU) |
| exact ⟨e.symm (some ⟨y,hy⟩),by simpa [point] using hxy⟩ |
|
|
| namespace DivisorProjectiveChart |
| variable {X : Scheme} [IsIntegral X] [IsLocallyNoetherian X] |
| {I : Type} {D : WeilDivisor X} {s : I → X.functionField} |
| def restrict (C : DivisorProjectiveChart X D s) (V : X.Opens) |
| (hV : V ≤ C.domain) (hv : genericPoint X ∈ V) : DivisorProjectiveChart X D s where |
| domain := V |
| generic_mem := hv |
| equation := C.equation |
| equation_ne_zero := C.equation_ne_zero |
| equation_order p hp := C.equation_order p (hV hp) |
| coordinate i := X.presheaf.map (homOfLE hV).op (C.coordinate i) |
| coordinate_value i := by |
| let : Nonempty V := ⟨⟨genericPoint X,hv⟩⟩ |
| let : Nonempty C.domain := ⟨⟨genericPoint X,C.generic_mem⟩⟩ |
| exact (germToFunctionField_restrict (homOfLE hV) (C.coordinate i)).trans |
| (C.coordinate_value i) |
| unit_index := C.unit_index |
| coordinate_unit := C.coordinate_unit.map _ |
| end DivisorProjectiveChart |
|
|
| lemma exists_affine_divisorProjectiveChart_inside |
| {X : Scheme} [IsIntegral X] [IsLocallyNoetherian X] |
| [StalkwiseNormal X] [CompactSpace X] |
| {I : Type} {D : WeilDivisor X} {s : I → X.functionField} |
| (hD : IsCartierDivisor D) (hs : ∀ i, s i ≠ 0 ∧ IsDivisorSection D (s i)) |
| (U : X.Opens) (x : X) (hxU : x ∈ U) |
| (hx : ∃ i, x ∈ sectionNonvanishing D (s i)) : |
| ∃ C : DivisorProjectiveChart X D s, |
| x ∈ C.domain ∧ IsAffineOpen C.domain ∧ C.domain ≤ U := by |
| obtain ⟨C,hC⟩ := exists_divisorProjectiveChart hD hs x hx |
| obtain ⟨V,hV,hxV,hVU⟩ := (Opens.isBasis_iff_nbhd.mp X.isBasis_affineOpens) |
| (show x ∈ C.domain ⊓ U from ⟨hC,hxU⟩) |
| have hgen : genericPoint X ∈ V := |
| ((genericPoint_spec X).mem_open_set_iff V.isOpen).mpr ⟨x,Set.mem_univ x,hxV⟩ |
| exact ⟨C.restrict V (le_trans hVU inf_le_left) hgen,hxV,hV, |
| le_trans hVU inf_le_right⟩ |
| end |
| end NumericalDimensionOne |
|
|
| end OAI |
|
|
