| import Mathlib |
| import OAI.AlgebraicGeometry.NumericalDimension.BirationalExtension |
|
|
| namespace OAI |
|
|
| /-! Projective Curves. -/ |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
|
|
| namespace NumericalDimensionOneCurveAux |
| open HomogeneousLocalization |
| attribute [local instance] MvPolynomial.gradedAlgebra |
|
|
| variable (k : Type*) [CommRing k] |
|
|
| abbrev planeGrading := MvPolynomial.homogeneousSubmodule (Fin 2) k |
| abbrev planeChart := HomogeneousLocalization.Away (planeGrading k) (MvPolynomial.X 1) |
|
|
| noncomputable def planeConstants : k →+* planeGrading k 0 where |
| toFun c := ⟨MvPolynomial.C c, MvPolynomial.isHomogeneous_C _ c⟩ |
| map_one' := Subtype.ext (map_one MvPolynomial.C) |
| map_zero' := Subtype.ext (map_zero MvPolynomial.C) |
| map_add' a b := Subtype.ext (map_add MvPolynomial.C a b) |
| map_mul' a b := Subtype.ext (map_mul MvPolynomial.C a b) |
|
|
| noncomputable def planeDehom : MvPolynomial (Fin 2) k →+* Polynomial k := |
| MvPolynomial.eval₂Hom Polynomial.C (fun i => if i = 0 then Polynomial.X else 1) |
|
|
| noncomputable def planeChartEval : planeChart k →+* Polynomial k := |
| (Localization.awayLift (planeDehom k) (MvPolynomial.X 1) |
| (isUnit_iff_exists_inv.mpr ⟨1, by simp [planeDehom]⟩)).comp |
| (algebraMap (planeChart k) (Localization.Away (MvPolynomial.X (1 : Fin 2) : |
| MvPolynomial (Fin 2) k))) |
|
|
| noncomputable def planeChartCoordinate : planeChart k := |
| HomogeneousLocalization.Away.mk (planeGrading k) |
| (MvPolynomial.isHomogeneous_X k 1) 1 (MvPolynomial.X 0) |
| (by simpa using MvPolynomial.isHomogeneous_X k (0 : Fin 2)) |
|
|
| noncomputable def planeChartInv : Polynomial k →+* planeChart k := |
| Polynomial.eval₂RingHom |
| ((HomogeneousLocalization.fromZeroRingHom (planeGrading k) _).comp (planeConstants k)) |
| (planeChartCoordinate k) |
|
|
| theorem planeConstants_surjective : Function.Surjective (planeConstants k) := by |
| intro p |
| refine ⟨p.val.coeff 0, Subtype.ext ?_⟩ |
| exact ((MvPolynomial.totalDegree_eq_zero_iff_eq_C).mp |
| ((MvPolynomial.totalDegree_zero_iff_isHomogeneous (Fin 2)).mpr p.property)).symm |
|
|
| theorem planeChartEval_mk (n : ℕ) (p : MvPolynomial (Fin 2) k) |
| (hp : p ∈ planeGrading k (n • 1)) : |
| planeChartEval k (HomogeneousLocalization.Away.mk (planeGrading k) |
| (MvPolynomial.isHomogeneous_X k 1) n p hp) = planeDehom k p := by |
| change (Localization.awayLift (planeDehom k) (MvPolynomial.X 1) |
| (isUnit_iff_exists_inv.mpr ⟨1, by simp [planeDehom]⟩)) |
| (Localization.mk p ⟨MvPolynomial.X (1 : Fin 2) ^ n, n, rfl⟩) = _ |
| simpa using Localization.awayLift_mk (planeDehom k) (MvPolynomial.X 1) p 1 |
| (by simp [planeDehom]) n |
|
|
| theorem planeChartEval_constants (c : k) : |
| planeChartEval k (HomogeneousLocalization.fromZeroRingHom (planeGrading k) _ |
| (planeConstants k c)) = Polynomial.C c := by |
| change planeChartEval k (HomogeneousLocalization.Away.mk (planeGrading k) |
| (MvPolynomial.isHomogeneous_X k 1) 0 (MvPolynomial.C c) |
| (by change (MvPolynomial.C c).IsHomogeneous 0; exact MvPolynomial.isHomogeneous_C _ c)) = _ |
| rw [planeChartEval_mk] |
| simp [planeDehom] |
|
|
| theorem planeChartEval_coordinate : |
| planeChartEval k (planeChartCoordinate k) = Polynomial.X := by |
| rw [planeChartCoordinate, planeChartEval_mk] |
| simp [planeDehom] |
|
|
| theorem planeChartEval_inv : (planeChartEval k).comp (planeChartInv k) = RingHom.id _ := by |
| apply Polynomial.ringHom_ext |
| · intro c |
| simp [planeChartInv, planeChartEval_constants] |
| · simp [planeChartInv, planeChartEval_coordinate] |
|
|
| theorem planeGrading_adjoin_X : |
| Algebra.adjoin (planeGrading k 0) (Set.range (MvPolynomial.X : Fin 2 → |
| MvPolynomial (Fin 2) k)) = ⊤ := by |
| apply top_unique |
| intro p hp |
| clear hp |
| induction p using MvPolynomial.induction_on with |
| | C c => exact (Algebra.adjoin _ _).algebraMap_mem (planeConstants k c) |
| | add p q hp hq => exact (Algebra.adjoin _ _).add_mem hp hq |
| | mul_X p i hp => |
| exact (Algebra.adjoin _ _).mul_mem hp (Algebra.subset_adjoin ⟨i, rfl⟩) |
|
|
| theorem planeChart_monomial (a : ℕ) (ai : Fin 2 → ℕ) |
| (hai : ∑ i, ai i • (1 : ℕ) = a • 1) : |
| HomogeneousLocalization.Away.mk (planeGrading k) |
| (MvPolynomial.isHomogeneous_X k 1) a (∏ i, MvPolynomial.X i ^ ai i) |
| (hai ▸ SetLike.prod_pow_mem_graded _ _ _ _ |
| (fun i _ => MvPolynomial.isHomogeneous_X k i)) = |
| planeChartCoordinate k ^ ai 0 := by |
| have ha : a = ai 0 + ai 1 := by simpa [Fin.sum_univ_two] using hai.symm |
| apply HomogeneousLocalization.val_injective |
| rw [HomogeneousLocalization.val_pow] |
| change (Localization.mk (∏ i, MvPolynomial.X i ^ ai i) |
| ⟨(MvPolynomial.X (1 : Fin 2) : MvPolynomial (Fin 2) k) ^ a, a, rfl⟩ : |
| Localization.Away (MvPolynomial.X (1 : Fin 2) : MvPolynomial (Fin 2) k)) = |
| (Localization.mk (MvPolynomial.X (0 : Fin 2)) |
| ⟨(MvPolynomial.X (1 : Fin 2) : MvPolynomial (Fin 2) k) ^ 1, 1, rfl⟩ : |
| Localization.Away (MvPolynomial.X (1 : Fin 2) : MvPolynomial (Fin 2) k)) ^ ai 0 |
| rw [Localization.mk_pow, Localization.mk_eq_mk_iff, Localization.r_iff_exists] |
| refine ⟨1, ?_⟩ |
| simp only [ha, Fin.prod_univ_two, OneMemClass.coe_one, one_mul, pow_one, |
| SubmonoidClass.coe_pow, pow_add] |
| ring |
|
|
| theorem planeChartInv_bijective : Function.Bijective (planeChartInv k) := by |
| constructor |
| · exact Function.HasLeftInverse.injective ⟨planeChartEval k, |
| fun p => congrArg (fun f : Polynomial k →+* Polynomial k => f p) (planeChartEval_inv k)⟩ |
| · intro x |
| have hspan := HomogeneousLocalization.Away.span_mk_prod_pow_eq_top |
| (MvPolynomial.isHomogeneous_X k 1) (MvPolynomial.X : Fin 2 → MvPolynomial (Fin 2) k) |
| (planeGrading_adjoin_X k) (fun _ => 1) |
| (fun i => MvPolynomial.isHomogeneous_X k i) |
| have hx : x ∈ Submodule.span (planeGrading k 0) |
| { (HomogeneousLocalization.Away.mk (planeGrading k) |
| (MvPolynomial.isHomogeneous_X k 1) a (∏ i, MvPolynomial.X i ^ ai i) |
| (hai ▸ SetLike.prod_pow_mem_graded _ _ _ _ |
| (fun i _ => MvPolynomial.isHomogeneous_X k i)) : planeChart k) | |
| (a : ℕ) (ai : Fin 2 → ℕ) (hai : ∑ i, ai i • (1 : ℕ) = a • 1) } := by |
| rw [hspan] |
| trivial |
| induction hx using Submodule.span_induction with |
| | mem y hy => |
| obtain ⟨a, ai, hai, rfl⟩ := hy |
| refine ⟨Polynomial.X ^ ai 0, ?_⟩ |
| simpa [planeChartInv] using (planeChart_monomial k a ai hai).symm |
| | zero => exact ⟨0, map_zero _⟩ |
| | add y z _ _ hy hz => |
| obtain ⟨p, rfl⟩ := hy |
| obtain ⟨q, rfl⟩ := hz |
| exact ⟨p + q, map_add _ _ _⟩ |
| | smul c y _ hy => |
| obtain ⟨p, rfl⟩ := hy |
| obtain ⟨c, rfl⟩ := planeConstants_surjective k c |
| refine ⟨Polynomial.C c * p, ?_⟩ |
| simp [planeChartInv, Algebra.smul_def, HomogeneousLocalization.algebraMap_eq] |
|
|
| end NumericalDimensionOneCurveAux |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
|
|
| namespace NumericalDimensionOneCurveAux |
|
|
| variable {A σ : Type*} [CommRing A] [SetLike σ A] [AddSubgroupClass σ A] |
| (G : ℕ → σ) [GradedRing G] |
|
|
| theorem proj_integral [IsDomain A] (hG : HomogeneousIdeal.irrelevant G ≠ ⊥) : |
| IsIntegral (Proj G) := by |
| let η : ProjectiveSpectrum G := ⟨⊥, Ideal.isPrime_bot, |
| fun h => hG (le_antisymm h bot_le)⟩ |
| have hη : IsGenericPoint η Set.univ := by |
| apply Set.Subset.antisymm (Set.subset_univ _) |
| intro y _ |
| exact (ProjectiveSpectrum.le_iff_mem_closure G η y).mp (show (⊥ : HomogeneousIdeal G) ≤ y.asHomogeneousIdeal from bot_le) |
| let : IrreducibleSpace (Proj G) := (irreducibleSpace_def _).mpr hη.isIrreducible |
| let : ∀ x : Proj G, _root_.IsReduced ((Proj G).presheaf.stalk x) := fun x => by |
| let : x.asHomogeneousIdeal.toIdeal.IsPrime := x.isPrime |
| let H := HomogeneousLocalization.AtPrime G x.asHomogeneousIdeal.toIdeal |
| let : _root_.IsReduced H := isReduced_of_injective |
| (algebraMap H (Localization.AtPrime x.asHomogeneousIdeal.toIdeal)) |
| (HomogeneousLocalization.val_injective _) |
| exact isReduced_of_injective (Proj.stalkIso' G x) (Proj.stalkIso' G x).injective |
| let : IsReduced (Proj G) := isReduced_of_isReduced_stalk _ |
| exact isIntegral_of_irreducibleSpace_of_isReduced _ |
|
|
| end NumericalDimensionOneCurveAux |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
|
|
| namespace NumericalDimensionOneCurveAux |
| open AlgebraicGeometry CategoryTheory |
| attribute [local instance] MvPolynomial.gradedAlgebra |
|
|
| theorem planeXone_mem (k : Type*) [CommRing k] : |
| (MvPolynomial.X 1 : MvPolynomial (Fin 2) k) ∈ planeGrading k 1 := |
| MvPolynomial.isHomogeneous_X k 1 |
|
|
| noncomputable def complexAffineChart : Spec (.of (Polynomial ℂ)) ⟶ complexProjectiveSpace 1 := |
| Spec.map (CommRingCat.ofHom (planeChartEval ℂ)) ≫ |
| Proj.awayι (planeGrading ℂ) (MvPolynomial.X 1) |
| (planeXone_mem ℂ) (by decide : 0 < (1 : ℕ)) |
|
|
| theorem planeChartEval_bijective (k : Type*) [CommRing k] : |
| Function.Bijective (planeChartEval k) := by |
| have hleft : Function.LeftInverse (planeChartEval k) (planeChartInv k) := |
| fun p => congrArg (fun f : Polynomial k →+* Polynomial k => f p) (planeChartEval_inv k) |
| refine ⟨?_, hleft.surjective⟩ |
| intro x y h |
| obtain ⟨p, rfl⟩ := (planeChartInv_bijective k).2 x |
| obtain ⟨q, rfl⟩ := (planeChartInv_bijective k).2 y |
| rw [hleft p, hleft q] at h |
| exact congrArg (planeChartInv k) h |
|
|
| theorem complexAffineChart_isOpenImmersion : IsOpenImmersion complexAffineChart := by |
| let e := RingEquiv.ofBijective (planeChartEval ℂ) (planeChartEval_bijective ℂ) |
| let : IsIso (CommRingCat.ofHom (planeChartEval ℂ)) := e.toCommRingCatIso.isIso_hom |
| let : IsIso (Spec.map (CommRingCat.ofHom (planeChartEval ℂ))) := inferInstance |
| exact IsOpenImmersion.comp _ (Proj.awayι (planeGrading ℂ) (MvPolynomial.X 1) |
| (planeXone_mem ℂ) (by decide : 0 < (1 : ℕ))) |
|
|
| theorem planeAffineChart_toSpec (k : Type*) [CommRing k] : |
| (Spec.map (CommRingCat.ofHom (planeChartEval k)) ≫ |
| Proj.awayι (planeGrading k) (MvPolynomial.X 1) (planeXone_mem k) |
| (by decide : 0 < (1 : ℕ))) ≫ |
| (Proj.toSpecZero (planeGrading k) ≫ Spec.map (CommRingCat.ofHom (planeConstants k))) = |
| Spec.map (CommRingCat.ofHom (Polynomial.C : k →+* Polynomial k)) := by |
| rw [Category.assoc, Proj.awayι_toSpecZero_assoc, ← Spec.map_comp, ← Spec.map_comp] |
| congr 1 |
| apply CommRingCat.hom_ext |
| exact RingHom.ext (planeChartEval_constants k) |
|
|
| @[reassoc] |
| theorem complexAffineChart_over : |
| complexAffineChart ≫ complexProjectiveSpaceMap 1 = |
| Spec.map (CommRingCat.ofHom (Polynomial.C : ℂ →+* Polynomial ℂ)) := by |
| exact planeAffineChart_toSpec ℂ |
|
|
| theorem complexProjectiveLine_integral : IsIntegral (complexProjectiveSpace 1) := by |
| apply proj_integral |
| intro h |
| have hX := HomogeneousIdeal.mem_irrelevant_of_mem (planeGrading ℂ) |
| (by decide : 0 < (1 : ℕ)) (MvPolynomial.isHomogeneous_X ℂ (1 : Fin 2)) |
| rw [h] at hX |
| change MvPolynomial.X (1 : Fin 2) = (0 : MvPolynomial (Fin 2) ℂ) at hX |
| exact (MvPolynomial.X_ne_zero (1 : Fin 2)) hX |
|
|
| theorem complexProjectiveLine_nontrivial : Nontrivial (complexProjectiveSpace 1) := by |
| let : IsOpenImmersion complexAffineChart := complexAffineChart_isOpenImmersion |
| have hi := complexAffineChart.isOpenEmbedding.injective |
| let p : PrimeSpectrum (Polynomial ℂ) := ⟨⊥, Ideal.isPrime_bot⟩ |
| let q : PrimeSpectrum (Polynomial ℂ) := |
| ⟨RingHom.ker (Polynomial.evalRingHom (0 : ℂ)), RingHom.ker_isPrime _⟩ |
| have hpq : p ≠ q := by |
| intro h |
| have hX : Polynomial.X ∈ q.asIdeal := by simp [q] |
| rw [← h] at hX |
| change (Polynomial.X : Polynomial ℂ) = 0 at hX |
| exact Polynomial.X_ne_zero hX |
| exact ⟨⟨complexAffineChart p, complexAffineChart q, fun h => hpq (hi h)⟩⟩ |
|
|
| end NumericalDimensionOneCurveAux |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
|
|
| namespace NumericalDimensionOneCurveAux |
|
|
| theorem ringKrullDim_le_of_quasiFinite (R S : Type*) |
| [CommRing R] [CommRing S] [Algebra R S] [Algebra.QuasiFinite R S] : |
| ringKrullDim S ≤ ringKrullDim R := by |
| apply Order.krullDim_le_of_strictMono (f := PrimeSpectrum.comap (algebraMap R S)) |
| intro p q hpq |
| refine lt_of_le_of_ne (Ideal.comap_mono hpq.le) ?_ |
| intro heq |
| have hd := Algebra.QuasiFinite.isDiscrete_comap_preimage_singleton |
| (R := R) (S := S) (PrimeSpectrum.comap (algebraMap R S) p) |
| have hsp : p ⤳ q := (PrimeSpectrum.le_iff_specializes p q).mp hpq.le |
| have hp : p ∈ PrimeSpectrum.comap (algebraMap R S) ⁻¹' |
| {PrimeSpectrum.comap (algebraMap R S) p} := rfl |
| have hq : q ∈ PrimeSpectrum.comap (algebraMap R S) ⁻¹' |
| {PrimeSpectrum.comap (algebraMap R S) p} := heq.symm |
| exact hpq.ne (hd.eq_of_specializes hsp hp hq) |
|
|
| end NumericalDimensionOneCurveAux |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
|
|
| namespace NumericalDimensionOneCurveAux |
| section SmoothCharts |
| universe u |
| variable {k : Type u} [Field k] {X : Scheme.{u}} |
|
|
| noncomputable def schemeOpenScalar (sX : X ⟶ Spec (.of k)) (U : X.Opens) : |
| k →+* Γ(X, U) := |
| (sX.appLE ⊤ U (by simp)).hom.comp (Scheme.ΓSpecIso (.of k)).inv.hom |
|
|
| @[instance_reducible] |
| noncomputable def schemeOpenAlgebra (sX : X ⟶ Spec (.of k)) (U : X.Opens) : |
| Algebra k Γ(X, U) := (schemeOpenScalar sX U).toAlgebra |
|
|
| theorem exists_standard_smooth_chart (sX : X ⟶ Spec (.of k)) (n : ℕ) |
| [SmoothOfRelativeDimension n sX] (x : X) : |
| ∃ (U : X.Opens), IsAffineOpen U ∧ x ∈ U ∧ |
| RingHom.IsStandardSmoothOfRelativeDimension n (schemeOpenScalar sX U) := by |
| obtain ⟨U, _, V, hV, hxV, e, hf⟩ := |
| SmoothOfRelativeDimension.exists_isStandardSmoothOfRelativeDimension |
| (f := sX) (n := n) x |
| have hU : U = ⊤ := by |
| ext y |
| have hmem : sX.base x ∈ U := e hxV |
| rw [show sX.base x = y from Subsingleton.elim _ _] at hmem |
| exact ⟨fun _ => trivial, fun _ => hmem⟩ |
| subst U |
| refine ⟨V, hV, hxV, ?_⟩ |
| exact RingHom.isStandardSmoothOfRelativeDimension_respectsIso.right |
| (sX.appLE ⊤ V e).hom |
| (Scheme.ΓSpecIso (.of k)).symm.commRingCatIsoToRingEquiv hf |
|
|
| end SmoothCharts |
| end NumericalDimensionOneCurveAux |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
|
|
| namespace NumericalDimensionOneCurveAux |
|
|
| universe u |
|
|
| theorem coheight_le_of_smooth_dimension |
| {k : Type u} [Field k] {X : Scheme.{u}} |
| (sX : X ⟶ Spec (.of k)) (n : ℕ) |
| [SmoothOfRelativeDimension n sX] (x : X) : |
| Order.coheight x ≤ n := by |
| obtain ⟨U, hU, hxU, hs⟩ := exists_standard_smooth_chart sX n x |
| obtain ⟨g, _, hg⟩ := hs.exists_etale_mvPolynomial |
| let : Algebra (MvPolynomial (Fin n) k) Γ(X, U) := g.toAlgebra |
| let : Algebra.Etale (MvPolynomial (Fin n) k) Γ(X, U) := hg |
| have hdim : ringKrullDim Γ(X, U) ≤ n := by |
| have h := ringKrullDim_le_of_quasiFinite (MvPolynomial (Fin n) k) Γ(X, U) |
| simpa using h |
| let y : U := ⟨x, hxU⟩ |
| let := TopCat.Presheaf.algebra_section_stalk X.presheaf y |
| let := hU.isLocalization_stalk y |
| have hstalk : ringKrullDim (X.presheaf.stalk x) ≤ n := by |
| rw [IsLocalization.AtPrime.ringKrullDim_eq_height (hU.primeIdealOf y).asIdeal] |
| exact (Ideal.height_le_ringKrullDim_of_ne_top |
| (hU.primeIdealOf y).isPrime.ne_top).trans hdim |
| rw [ringKrullDim_stalk_eq_coheight] at hstalk |
| exact WithBot.coe_le_coe.mp hstalk |
|
|
| end NumericalDimensionOneCurveAux |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
|
|
| namespace NumericalDimensionOneCurveAux |
|
|
| theorem isIntegrallyClosed_of_etale_domain |
| (R S : Type*) [CommRing R] [IsDomain R] [IsIntegrallyClosed R] |
| [CommRing S] [IsDomain S] [Algebra R S] [Algebra.Etale R S] : |
| IsIntegrallyClosed S := by |
| let K := FractionRing R |
| let T := S ⊗[R] K |
| let : Algebra K T := Algebra.TensorProduct.rightAlgebra |
| have hinj : Function.Injective (algebraMap R S) := FaithfulSMul.algebraMap_injective R S |
| have hM : Algebra.algebraMapSubmonoid S R⁰ ≤ S⁰ := by |
| rintro x ⟨y, hy, rfl⟩ |
| exact mem_nonZeroDivisors_iff_ne_zero.mpr |
| ((map_ne_zero_iff _ hinj).mpr (mem_nonZeroDivisors_iff_ne_zero.mp hy)) |
| let : IsDomain T := IsLocalization.isDomain_of_le_nonZeroDivisors T hM |
| let : Algebra.Etale K T := Algebra.Etale.of_equiv |
| (Algebra.TensorProduct.commRight R K S) |
| let : Module.Finite K T := Algebra.FormallyUnramified.finite_of_free K T |
| let : IsArtinianRing T := .of_finite K T |
| let : Field T := (IsArtinianRing.isField_of_isDomain T).toField |
| have hST : Function.Injective (algebraMap S T) := IsLocalization.injective T hM |
| let : IsFractionRing S T := IsLocalization.of_le (Algebra.algebraMapSubmonoid S R⁰) S⁰ hM fun x hx => |
| isUnit_iff_ne_zero.mpr ((map_ne_zero_iff _ hST).mpr |
| (mem_nonZeroDivisors_iff_ne_zero.mp hx)) |
| apply (isIntegrallyClosed_iff T).mpr |
| intro x hx |
| obtain ⟨z, hz⟩ := |
| (TensorProduct.toIntegralClosure_bijective_of_smooth (R := R) (S := S) (B := K)).2 |
| ⟨x, hx⟩ |
| have hmem : ∀ z : S ⊗[R] integralClosure R K, |
| ∃ s : S, algebraMap S T s = (TensorProduct.toIntegralClosure R S K z).1 := by |
| intro z |
| induction z using TensorProduct.inductionOn with |
| | add x y hx hy => |
| obtain ⟨sx, hsx⟩ := hx |
| obtain ⟨sy, hsy⟩ := hy |
| exact ⟨sx + sy, by simp [hsx, hsy]⟩ |
| | tmul s y => |
| obtain ⟨r, hr⟩ := IsIntegrallyClosed.algebraMap_eq_of_integral y.2 |
| refine ⟨s * algebraMap R S r, ?_⟩ |
| simp only [map_mul, TensorProduct.toIntegralClosure, AlgHom.coe_codRestrict, |
| Algebra.TensorProduct.map_tmul, AlgHom.id_apply] |
| change (s ⊗ₜ[R] (1 : K)) * (algebraMap R S r ⊗ₜ[R] (1 : K)) = |
| s ⊗ₜ[R] (y : K) |
| rw [← hr] |
| simp [Algebra.TensorProduct.tmul_mul_tmul, Algebra.algebraMap_eq_smul_one, |
| TensorProduct.tmul_smul, TensorProduct.smul_tmul] |
| obtain ⟨s, hs⟩ := hmem z |
| exact ⟨s, hs.trans (congrArg Subtype.val hz)⟩ |
|
|
| theorem isIntegrallyClosed_of_smooth_field_domain |
| (k S : Type*) [Field k] [CommRing S] [IsDomain S] |
| [Algebra k S] [Algebra.Smooth k S] : IsIntegrallyClosed S := by |
| apply IsIntegrallyClosed.of_localization_maximal |
| intro p _ 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 hf : f ≠ 0 := fun h => hfp (h ▸ p.zero_mem) |
| let : IsDomain (Localization.Away f) := IsLocalization.Away.isDomain (Localization.Away f) hf |
| let : IsIntegrallyClosed (Localization.Away f) := |
| isIntegrallyClosed_of_etale_domain (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 S (Localization.Away f) (Localization.AtPrime p) := |
| IsLocalization.localization_isScalarTower_of_submonoid_le _ _ _ _ hle |
| let : IsLocalization (p.primeCompl.map (algebraMap S (Localization.Away f))) |
| (Localization.AtPrime p) := |
| IsLocalization.isLocalization_of_submonoid_le _ _ _ _ hle |
| apply isIntegrallyClosed_of_isLocalization (Localization.AtPrime p) |
| (p.primeCompl.map (algebraMap S (Localization.Away f))) |
| rintro x ⟨y, hy, rfl⟩ |
| exact mem_nonZeroDivisors_iff_ne_zero.mpr |
| ((map_ne_zero_iff _ (IsLocalization.injective (Localization.Away f) |
| (powers_le_nonZeroDivisors_of_noZeroDivisors hf))).mpr |
| (fun h => hy (h ▸ p.zero_mem))) |
|
|
| open AlgebraicGeometry CategoryTheory |
| universe u |
|
|
| theorem integrallyClosed_stalk_of_smooth_field |
| {k : Type u} [Field k] {X : Scheme.{u}} [IsIntegral X] |
| (f : X ⟶ Spec (.of k)) [Smooth f] (x : X) : |
| IsIntegrallyClosed (X.presheaf.stalk x) := by |
| obtain ⟨U, hU, hxU, _⟩ := exists_isAffineOpen_mem_and_subset |
| (show x ∈ (⊤ : X.Opens) from trivial) |
| let : Nonempty U := ⟨⟨x, hxU⟩⟩ |
| obtain ⟨φ, hφ⟩ := Spec.map_surjective (hU.fromSpec ≫ f) |
| have hs : Smooth (Spec.map φ) := hφ ▸ inferInstance |
| have hs' : φ.hom.Smooth := |
| (HasRingHomProperty.Spec_iff (P := @Smooth)).mp hs |
| let : Algebra k Γ(X, U) := φ.hom.toAlgebra |
| let : Algebra.Smooth k Γ(X, U) := hs' |
| let : IsIntegrallyClosed Γ(X, U) := isIntegrallyClosed_of_smooth_field_domain k Γ(X, U) |
| let y : U := ⟨x, hxU⟩ |
| let := TopCat.Presheaf.algebra_section_stalk X.presheaf y |
| let := hU.isLocalization_stalk y |
| exact isIntegrallyClosed_of_isLocalization (X.presheaf.stalk x) |
| (hU.primeIdealOf y).asIdeal.primeCompl |
| (hU.primeIdealOf y).asIdeal.primeCompl_le_nonZeroDivisors |
|
|
| end NumericalDimensionOneCurveAux |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
|
|
| namespace NumericalDimensionOneCurveAux |
| open AlgebraicGeometry CategoryTheory |
| universe u |
|
|
| theorem valuationRing_stalk_of_smooth_curve |
| {k : Type u} [Field k] {C : Scheme.{u}} [IsIntegral C] |
| (sC : C ⟶ Spec (.of k)) [SmoothOfRelativeDimension 1 sC] (x : C) : |
| ValuationRing (C.presheaf.stalk x) := by |
| let : Smooth sC := SmoothOfRelativeDimension.smooth 1 sC |
| let : IsLocallyNoetherian C := LocallyOfFiniteType.isLocallyNoetherian sC |
| let : IsIntegrallyClosed (C.presheaf.stalk x) := |
| integrallyClosed_stalk_of_smooth_field sC x |
| let : Ring.KrullDimLE 1 (C.presheaf.stalk x) := |
| krullDimLE_of_coheight_le (coheight_le_of_smooth_dimension sC 1 x) |
| by_cases hfield : IsField (C.presheaf.stalk x) |
| · let := hfield.toField |
| infer_instance |
| · let : Ring.DimensionLEOne (C.presheaf.stalk x) := |
| ⟨fun {I} hI hprime => |
| Ring.krullDimLE_one_iff_of_noZeroDivisors.mp inferInstance I hI hprime⟩ |
| let : IsDedekindDomain (C.presheaf.stalk x) := { } |
| let : IsDiscreteValuationRing (C.presheaf.stalk x) := |
| ((IsDiscreteValuationRing.TFAE (C.presheaf.stalk x) hfield).out 3 1).mp |
| (show IsDedekindDomain (C.presheaf.stalk x) from inferInstance) |
| infer_instance |
|
|
| end NumericalDimensionOneCurveAux |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
|
|
| namespace NumericalDimensionOneCurveAux |
| open AlgebraicGeometry CategoryTheory AlgebraicGeometry.Scheme |
| universe u |
|
|
| lemma partial_fromFunctionField_eq {C Y : Scheme.{u}} [IsIntegral C] |
| (f : C.PartialMap Y) {x : C} (hx : x ∈ f.domain) : |
| f.fromFunctionField = |
| Spec.map (CommRingCat.ofHom (algebraMap (C.presheaf.stalk x) C.functionField)) ≫ |
| f.fromSpecStalkOfMem hx := by |
| have hη : genericPoint C ∈ f.domain := |
| (genericPoint_specializes x).mem_open f.domain.2 hx |
| have h : f.domain.fromSpecStalkOfMem (genericPoint C) hη = |
| Spec.map (CommRingCat.ofHom (algebraMap (C.presheaf.stalk x) C.functionField)) ≫ |
| f.domain.fromSpecStalkOfMem x hx := by |
| apply (cancel_mono f.domain.ι).mp |
| rw [Category.assoc, Scheme.Opens.fromSpecStalkOfMem_ι, |
| Scheme.Opens.fromSpecStalkOfMem_ι] |
| exact (C.SpecMap_stalkSpecializes_fromSpecStalk (genericPoint_specializes x)).symm |
| change f.domain.fromSpecStalkOfMem (genericPoint C) hη ≫ f.hom = _ |
| rw [h, Category.assoc] |
| rfl |
|
|
| end NumericalDimensionOneCurveAux |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
| open AlgebraicGeometry CategoryTheory TopologicalSpace |
|
|
| namespace NumericalDimensionOneCurveAux |
| open AlgebraicGeometry CategoryTheory AlgebraicGeometry.Scheme |
| universe u |
|
|
| theorem exists_extension_from_functionField_of_smooth_curve |
| {k : Type u} [Field k] {C Y : Scheme.{u}} [IsIntegral C] |
| (sC : C ⟶ Spec (.of k)) [SmoothOfRelativeDimension 1 sC] |
| (sY : Y ⟶ Spec (.of k)) [IsProper sY] |
| (g : Spec C.functionField ⟶ Y) |
| (hg : g ≫ sY = C.fromSpecStalk (genericPoint C) ≫ sC) : |
| ∃ f : C ⟶ Y, C.fromSpecStalk (genericPoint C) ≫ f = g ∧ f ≫ sY = sC := by |
| let : Y.IsSeparated := by |
| constructor |
| rw [← Limits.terminal.comp_from sY] |
| infer_instance |
| let r := RationalMap.ofFunctionField sC sY g hg |
| have hr : r.fromFunctionField = g := RationalMap.fromFunctionField_ofFunctionField _ _ _ _ |
| have hdomain : r.domain = ⊤ := by |
| apply top_unique |
| intro x _ |
| let : ValuationRing (C.presheaf.stalk x) := valuationRing_stalk_of_smooth_curve sC x |
| have hv : ValuativeCriterion.Existence sY := by |
| have h : UniversallyClosed sY := inferInstance |
| rw [UniversallyClosed.eq_valuativeCriterion] at h |
| exact h.1 |
| have hw : g ≫ sY = |
| Spec.map (CommRingCat.ofHom (algebraMap (C.presheaf.stalk x) C.functionField)) ≫ |
| (C.fromSpecStalk x ≫ sC) := by |
| rw [hg, ← Category.assoc] |
| exact congrArg (fun t => t ≫ sC) |
| (C.SpecMap_stalkSpecializes_fromSpecStalk (genericPoint_specializes x)).symm |
| obtain ⟨l, hlg, hl⟩ := (hv { |
| R := C.presheaf.stalk x |
| commRing := inferInstanceAs (CommRing (C.presheaf.stalk x)) |
| domain := inferInstanceAs (IsDomain (C.presheaf.stalk x)) |
| K := C.functionField |
| i₁ := g |
| i₂ := C.fromSpecStalk x ≫ sC |
| commSq := ⟨hw⟩ }).exists_lift |
| let p := PartialMap.ofFromSpecStalk sC sY l hl |
| have hx : x ∈ p.domain := PartialMap.mem_domain_ofFromSpecStalk _ _ _ _ |
| apply RationalMap.mem_domain.mpr |
| refine ⟨p, hx, RationalMap.eq_of_fromFunctionField_eq _ _ ?_⟩ |
| rw [RationalMap.fromFunctionField_toRationalMap, partial_fromFunctionField_eq p hx, |
| PartialMap.fromSpecStalkOfMem_ofFromSpecStalk, hr] |
| exact hlg |
| let p := r.toPartialMap |
| have hpdom : p.domain = ⊤ := hdomain |
| let : IsIso p.domain.ι := by |
| rw [hpdom] |
| change IsIso C.topIso.hom |
| infer_instance |
| let f := inv p.domain.ι ≫ p.hom |
| have hf : C.fromSpecStalk (genericPoint C) ≫ f = g := by |
| have hη : genericPoint C ∈ p.domain := by rw [hpdom]; trivial |
| have hi : C.fromSpecStalk (genericPoint C) ≫ inv p.domain.ι = |
| p.domain.fromSpecStalkOfMem (genericPoint C) hη := by |
| apply (cancel_mono p.domain.ι).mp |
| simp only [Category.assoc, IsIso.inv_hom_id, Category.comp_id, |
| Scheme.Opens.fromSpecStalkOfMem_ι] |
| change C.fromSpecStalk (genericPoint C) ≫ inv p.domain.ι ≫ p.hom = g |
| rw [← Category.assoc, hi] |
| change p.fromFunctionField = g |
| rw [← RationalMap.fromFunctionField_toRationalMap, RationalMap.toRationalMap_toPartialMap, hr] |
| refine ⟨f, hf, ?_⟩ |
| let : IsDominant (C.fromSpecStalk (genericPoint C)) := ⟨by |
| have hden : Dense ({genericPoint C} : Set C) := |
| dense_iff_closure_eq.mpr (genericPoint_spec C) |
| exact hden.mono (Set.singleton_subset_iff.mpr ⟨_, C.fromSpecStalk_closedPoint⟩)⟩ |
| apply ext_of_isDominant (C.fromSpecStalk (genericPoint C)) |
| rw [← Category.assoc, hf, hg] |
|
|
| end NumericalDimensionOneCurveAux |
|
|
| end OAI |
|
|
