| import Mathlib |
| import OAI.AlgebraicGeometry.NumericalDimension.NormalDivisors |
|
|
| namespace OAI |
|
|
| /-! Rational Pullbacks. -/ |
|
|
| open AlgebraicGeometry CategoryTheory |
|
|
| namespace NumericalDimensionOne |
| section CartierLocalUnits |
| variable {Y : Scheme} [IsIntegral Y] [IsLocallyNoetherian Y] [StalkwiseNormal Y] |
|
|
| omit [StalkwiseNormal Y] in |
| lemma order_div {g h : Y.functionField} (hg : g ≠ 0) (hh : h ≠ 0) (y : Y) : |
| Y.ord (g / h) y = Y.ord g y - Y.ord h y := by |
| rw [div_eq_mul_inv, Y.ord_mul hg (inv_ne_zero hh), order_inv h hh, sub_eq_add_neg] |
|
|
| lemma affine_unit_of_zero_orders {U : Y.Opens} (hU : IsAffineOpen U) [Nonempty U] |
| {g : Y.functionField} (hg : g ≠ 0) |
| (hord : ∀ p : PrimeDivisor Y, p.1 ∈ U → Y.ord g p.1 = 0) : |
| ∃ u : Γ(Y, U), IsUnit u ∧ Y.germToFunctionField U u = g := by |
| obtain ⟨u, hu⟩ := (affine_regular_iff_nonnegative_orders hU g).mpr |
| (Or.inr (fun p hp => le_of_eq (hord p hp).symm)) |
| obtain ⟨v, hv⟩ := (affine_regular_iff_nonnegative_orders hU g⁻¹).mpr |
| (Or.inr (fun p hp => by rw [order_inv g hg, hord p hp]; omega)) |
| refine ⟨u, ?_, hu⟩ |
| apply isUnit_iff_exists_inv.mpr |
| refine ⟨v, ?_⟩ |
| apply Y.germToFunctionField_injective U |
| rw [map_mul, hu, hv, mul_inv_cancel₀ hg, map_one] |
|
|
| lemma local_equation_ratio_unit {D : WeilDivisor Y} {U V : Y.Opens} |
| {g h : Y.functionField} (hg : g ≠ 0) (hh : h ≠ 0) |
| (hDg : ∀ p : PrimeDivisor Y, p.1 ∈ U → D p = Y.ord g p.1) |
| (hDh : ∀ p : PrimeDivisor Y, p.1 ∈ V → D p = Y.ord h p.1) |
| {y : Y} (hyU : y ∈ U) (hyV : y ∈ V) : |
| ∃ u : Y.presheaf.stalk y, IsUnit u ∧ |
| algebraMap (Y.presheaf.stalk y) Y.functionField u = g / h := by |
| obtain ⟨W, hW, hyW, hsub⟩ := exists_isAffineOpen_mem_and_subset |
| (show y ∈ U ⊓ V from ⟨hyU, hyV⟩) |
| let : Nonempty W := ⟨⟨y, hyW⟩⟩ |
| obtain ⟨u, hu, heq⟩ := affine_unit_of_zero_orders hW (div_ne_zero hg hh) |
| (fun p hp => by rw [order_div hg hh, ← hDg p (hsub hp).1, ← hDh p (hsub hp).2]; omega) |
| refine ⟨Y.presheaf.germ W y hyW u, hu.map (Y.presheaf.germ W y hyW).hom, ?_⟩ |
| rw [Y.algebraMap_germ_eq_germToFunctionField hyW, heq] |
|
|
| end CartierLocalUnits |
|
|
| section CartierLocalPullback |
| variable {X Y : Scheme} [IsIntegral X] [IsIntegral Y] |
| [IsLocallyNoetherian X] [IsLocallyNoetherian Y] [StalkwiseNormal Y] |
|
|
| omit [IsIntegral Y] [IsLocallyNoetherian Y] [StalkwiseNormal Y] in |
| lemma order_stalk_unit (p : PrimeDivisor X) {a : X.presheaf.stalk p.1} |
| (ha : IsUnit a) : X.ord (algebraMap (X.presheaf.stalk p.1) X.functionField a) p.1 = 0 := by |
| let : Ring.KrullDimLE 1 (X.presheaf.stalk p.1) := krullDimLE_of_coheight_le p.2.le |
| apply (X.ord_eq_iff p.2 (ha.map (algebraMap _ _)).ne_zero).mpr |
| exact Ring.ordFrac_of_isUnit ha |
|
|
| lemma pulled_equation_order_eq (f : X ⟶ Y) [IsDominant f] |
| {D : WeilDivisor Y} {U V : Y.Opens} {g h : Y.functionField} |
| (hg : g ≠ 0) (hh : h ≠ 0) |
| (hDg : ∀ p : PrimeDivisor Y, p.1 ∈ U → D p = Y.ord g p.1) |
| (hDh : ∀ p : PrimeDivisor Y, p.1 ∈ V → D p = Y.ord h p.1) |
| (p : PrimeDivisor X) (hpU : f p.1 ∈ U) (hpV : f p.1 ∈ V) : |
| X.ord (dominantFunctionFieldMap f g) p.1 = X.ord (dominantFunctionFieldMap f h) p.1 := by |
| obtain ⟨u, hu, heq⟩ := local_equation_ratio_unit hg hh hDg hDh hpU hpV |
| have ho := order_stalk_unit p (hu.map (f.stalkMap p.1).hom) |
| rw [← dominantFunctionFieldMap_algebraMap f p.1 u, heq, map_div₀, |
| order_div ((map_ne_zero (dominantFunctionFieldMap f)).mpr hg) |
| ((map_ne_zero (dominantFunctionFieldMap f)).mpr hh)] at ho |
| omega |
|
|
| end CartierLocalPullback |
| end NumericalDimensionOne |
|
|
| open AlgebraicGeometry CategoryTheory |
|
|
| namespace NumericalDimensionOne |
|
|
| theorem exists_cartierPullback {X Y : Scheme} [IsIntegral X] [IsIntegral Y] |
| [IsLocallyNoetherian X] [IsLocallyNoetherian Y] [StalkwiseNormal Y] [CompactSpace X] |
| (f : X ⟶ Y) [IsDominant f] (D : WeilDivisor Y) (hD : IsCartierDivisor D) : |
| ∃ E : WeilDivisor X, IsCartierPullback f D E := by |
| classical |
| choose U hU hxU g hg hDg using hD |
| let c : PrimeDivisor X → ℤ := fun p => X.ord (dominantFunctionFieldMap f (g (f p.1))) p.1 |
| have hc (p : PrimeDivisor X) (y : Y) (hp : f p.1 ∈ U y) : |
| c p = X.ord (dominantFunctionFieldMap f (g y)) p.1 := |
| pulled_equation_order_eq f (hg (f p.1)) (hg y) (hDg (f p.1)) (hDg y) |
| p (hxU (f p.1)) hp |
| let y₀ : Y := f (genericPoint X) |
| let V : X.Opens := f ⁻¹ᵁ U y₀ |
| have hV : (V : Set X)ᶜ ≠ Set.univ := by |
| intro h |
| have hm : genericPoint X ∈ (V : Set X)ᶜ := by rw [h]; trivial |
| exact hm (hxU y₀) |
| have hfinite : (Function.support c).Finite := by |
| apply ((ord_finite_support (dominantFunctionFieldMap f (g y₀))).union |
| (finite_primeDivisors_in_closed V.isOpen.isClosed_compl hV)).subset |
| intro p hp |
| by_cases hpV : f p.1 ∈ U y₀ |
| · left |
| change X.ord (dominantFunctionFieldMap f (g y₀)) p.1 ≠ 0 |
| intro hz |
| exact hp ((hc p y₀ hpV).trans hz) |
| · exact Or.inr hpV |
| let E : WeilDivisor X := Finsupp.ofSupportFinite c hfinite |
| refine ⟨E, ?_⟩ |
| intro x |
| refine ⟨U (f x), hU (f x), hxU (f x), g (f x), hg (f x), hDg (f x), ?_⟩ |
| intro p hp |
| exact hc p (f x) hp |
|
|
| end NumericalDimensionOne |
|
|
| open AlgebraicGeometry CategoryTheory |
|
|
| namespace NumericalDimensionOne |
| section PullbackProperties |
| variable {X Y : Scheme} [IsIntegral X] [IsIntegral Y] |
| [IsLocallyNoetherian X] [IsLocallyNoetherian Y] |
|
|
| theorem IsCartierPullback.isCartier {f : X ⟶ Y} [IsDominant f] |
| {D : WeilDivisor Y} {E : WeilDivisor X} (hE : IsCartierPullback f D E) : |
| IsCartierDivisor E := by |
| intro x |
| obtain ⟨U, _, hx, g, hg, _, hEg⟩ := hE x |
| obtain ⟨V, hV, hxV, hVU⟩ := exists_isAffineOpen_mem_and_subset |
| (show x ∈ f ⁻¹ᵁ U from hx) |
| refine ⟨V, hV, hxV, dominantFunctionFieldMap f g, |
| (map_ne_zero _).mpr hg, ?_⟩ |
| exact fun p hp => hEg p (hVU hp) |
|
|
| theorem IsCartierPullback.unique [StalkwiseNormal Y] {f : X ⟶ Y} [IsDominant f] |
| {D : WeilDivisor Y} {E F : WeilDivisor X} |
| (hE : IsCartierPullback f D E) (hF : IsCartierPullback f D F) : E = F := by |
| ext p |
| obtain ⟨U, _, hpU, g, hg, hDg, hEg⟩ := hE p.1 |
| obtain ⟨V, _, hpV, h, hh, hDh, hFh⟩ := hF p.1 |
| rw [hEg p hpU, hFh p hpV] |
| exact pulled_equation_order_eq f hg hh hDg hDh p hpU hpV |
|
|
| theorem IsCartierPullback.add {f : X ⟶ Y} [IsDominant f] |
| {D₁ D₂ : WeilDivisor Y} {E₁ E₂ : WeilDivisor X} |
| (h₁ : IsCartierPullback f D₁ E₁) (h₂ : IsCartierPullback f D₂ E₂) : |
| IsCartierPullback f (D₁ + D₂) (E₁ + E₂) := by |
| intro x |
| obtain ⟨U, _, hxU, g, hg, hDg, hEg⟩ := h₁ x |
| obtain ⟨V, _, hxV, h, hh, hDh, hEh⟩ := h₂ x |
| obtain ⟨W, hW, hxW, hsub⟩ := exists_isAffineOpen_mem_and_subset |
| (show f x ∈ U ⊓ V from ⟨hxU, hxV⟩) |
| refine ⟨W, hW, hxW, g * h, mul_ne_zero hg hh, ?_, ?_⟩ |
| · intro p hp |
| simp only [Finsupp.add_apply, hDg p (hsub hp).1, hDh p (hsub hp).2, |
| Y.ord_mul hg hh] |
| · intro p hp |
| simp only [Finsupp.add_apply, hEg p (hsub hp).1, hEh p (hsub hp).2, |
| map_mul, X.ord_mul ((map_ne_zero _).mpr hg) ((map_ne_zero _).mpr hh)] |
|
|
| theorem IsCartierPullback.neg {f : X ⟶ Y} [IsDominant f] |
| {D : WeilDivisor Y} {E : WeilDivisor X} (hE : IsCartierPullback f D E) : |
| IsCartierPullback f (-D) (-E) := by |
| intro x |
| obtain ⟨U, hU, hx, g, hg, hDg, hEg⟩ := hE x |
| refine ⟨U, hU, hx, g⁻¹, inv_ne_zero hg, ?_, ?_⟩ |
| · intro p hp |
| simp only [Finsupp.neg_apply, hDg p hp, order_inv g hg] |
| · intro p hp |
| simp only [Finsupp.neg_apply, hEg p hp, map_inv₀, |
| order_inv (dominantFunctionFieldMap f g) ((map_ne_zero (dominantFunctionFieldMap f)).mpr hg)] |
|
|
| theorem isCartierPullback_zero (f : X ⟶ Y) [IsDominant f] : |
| IsCartierPullback f 0 0 := by |
| intro x |
| let U : Y.Opens := (Y.affineCover.f (Y.affineCover.idx (f x))).opensRange |
| refine ⟨U, isAffineOpen_opensRange _, Y.affineCover.covers _, 1, one_ne_zero, ?_, ?_⟩ |
| · intro p _; simp [order_one] |
| · intro p _; simp [order_one] |
|
|
| theorem isCartierPullback_principal [CompactSpace X] [CompactSpace Y] |
| (f : X ⟶ Y) [IsDominant f] (g : Y.functionField) (hg : g ≠ 0) : |
| IsCartierPullback f (principalWeilDivisor g) |
| (principalWeilDivisor (dominantFunctionFieldMap f g)) := by |
| intro x |
| let U : Y.Opens := (Y.affineCover.f (Y.affineCover.idx (f x))).opensRange |
| exact ⟨U, isAffineOpen_opensRange _, Y.affineCover.covers _, g, hg, |
| fun _ _ => rfl, fun _ _ => rfl⟩ |
|
|
| end PullbackProperties |
| end NumericalDimensionOne |
|
|
| open AlgebraicGeometry CategoryTheory |
|
|
| namespace NumericalDimensionOne |
| section CurvePullbackDefinition |
| variable {C Y : Scheme} [IsIntegral C] [IsIntegral Y] |
| [IsLocallyNoetherian C] [IsLocallyNoetherian Y] |
|
|
| def IsPulledCartierRepresentative (f : C ⟶ Y) |
| (D : WeilDivisor Y) (E : WeilDivisor C) : Prop := |
| ∃ U : Y.Opens, IsAffineOpen U ∧ f (genericPoint C) ∈ U ∧ |
| ∃ g : Y.functionField, g ≠ 0 ∧ |
| (∀ p : PrimeDivisor Y, p.1 ∈ U → D p = Y.ord g p.1) ∧ |
| ∀ x : C, ∃ V : Y.Opens, IsAffineOpen V ∧ f x ∈ V ∧ |
| ∃ h : Y.functionField, h ≠ 0 ∧ |
| (∀ p : PrimeDivisor Y, p.1 ∈ V → D p = Y.ord h p.1) ∧ |
| ∃ a : Y.presheaf.stalk (f (genericPoint C)), IsUnit a ∧ |
| algebraMap (Y.presheaf.stalk (f (genericPoint C))) Y.functionField a = h / g ∧ |
| (∀ p : PrimeDivisor C, f p.1 ∈ V → |
| E p = C.ord (f.stalkMap (genericPoint C) a) p.1) |
|
|
| end CurvePullbackDefinition |
| end NumericalDimensionOne |
|
|
| open AlgebraicGeometry CategoryTheory |
|
|
| namespace NumericalDimensionOne |
| section CurvePullbackLocal |
| variable {C Y : Scheme} [IsIntegral C] [IsIntegral Y] |
| [IsLocallyNoetherian C] [IsLocallyNoetherian Y] [StalkwiseNormal Y] |
|
|
| omit [IsIntegral Y] [IsLocallyNoetherian C] [IsLocallyNoetherian Y] [StalkwiseNormal Y] in |
| lemma image_generic_mem (f : C ⟶ Y) {U : Y.Opens} {x : C} (hx : f x ∈ U) : |
| f (genericPoint C) ∈ U := by |
| exact (f.base.hom.map_specializes ((genericPoint_spec C).specializes trivial)).mem_open U.isOpen hx |
|
|
| omit [IsLocallyNoetherian C] [IsLocallyNoetherian Y] [StalkwiseNormal Y] in |
| lemma algebraMap_stalkSpecializes {x y : Y} (h : x ⤳ y) (a : Y.presheaf.stalk y) : |
| algebraMap (Y.presheaf.stalk x) Y.functionField (Y.presheaf.stalkSpecializes h a) = |
| algebraMap (Y.presheaf.stalk y) Y.functionField a := by |
| exact Y.presheaf.stalkSpecializes_comp_apply |
| ((genericPoint_spec Y).specializes trivial) h a |
|
|
| lemma curve_equation_order_eq (f : C ⟶ Y) {D : WeilDivisor Y} |
| {U V : Y.Opens} {g h anchor : Y.functionField} |
| (hg : g ≠ 0) (hh : h ≠ 0) (ha : anchor ≠ 0) |
| (hDg : ∀ p : PrimeDivisor Y, p.1 ∈ U → D p = Y.ord g p.1) |
| (hDh : ∀ p : PrimeDivisor Y, p.1 ∈ V → D p = Y.ord h p.1) |
| (a b : Y.presheaf.stalk (f (genericPoint C))) (hb : IsUnit b) |
| (hag : algebraMap _ Y.functionField a = g / anchor) |
| (hbh : algebraMap _ Y.functionField b = h / anchor) |
| (p : PrimeDivisor C) (hpU : f p.1 ∈ U) (hpV : f p.1 ∈ V) : |
| C.ord (f.stalkMap (genericPoint C) a) p.1 = |
| C.ord (f.stalkMap (genericPoint C) b) p.1 := by |
| obtain ⟨u, hu, heq⟩ := local_equation_ratio_unit hg hh hDg hDh hpU hpV |
| let hs : genericPoint C ⤳ p.1 := (genericPoint_spec C).specializes trivial |
| let uy := Y.presheaf.stalkSpecializes (f.base.hom.map_specializes hs) u |
| have hprod : a = b * uy := by |
| apply IsFractionRing.injective (Y.presheaf.stalk (f (genericPoint C))) Y.functionField |
| rw [map_mul, hag, hbh, algebraMap_stalkSpecializes, heq] |
| field_simp |
| have hz : C.ord (f.stalkMap (genericPoint C) uy) p.1 = 0 := by |
| rw [f.stalkSpecializes_stalkMap_apply (genericPoint C) p.1 hs u] |
| exact order_stalk_unit p (hu.map (f.stalkMap p.1).hom) |
| rw [hprod, map_mul] |
| rw [C.ord_mul |
| (hb.map (f.stalkMap (genericPoint C)).hom).ne_zero |
| ((hu.map (Y.presheaf.stalkSpecializes (f.base.hom.map_specializes hs)).hom).map |
| (f.stalkMap (genericPoint C)).hom).ne_zero] |
| rw [hz, add_zero] |
|
|
| end CurvePullbackLocal |
| end NumericalDimensionOne |
|
|
| open AlgebraicGeometry CategoryTheory |
|
|
| namespace NumericalDimensionOne |
|
|
| theorem exists_pulledCartierRepresentative {C Y : Scheme} [IsIntegral C] [IsIntegral Y] |
| [IsLocallyNoetherian C] [IsLocallyNoetherian Y] [StalkwiseNormal Y] [CompactSpace C] |
| (f : C ⟶ Y) (D : WeilDivisor Y) (hD : IsCartierDivisor D) : |
| ∃ E : WeilDivisor C, IsPulledCartierRepresentative f D E := by |
| classical |
| choose U hU hyU g hg hDg using hD |
| let y₀ : Y := f (genericPoint C) |
| have hlocal (x : C) : ∃ a : Y.presheaf.stalk y₀, IsUnit a ∧ |
| algebraMap _ Y.functionField a = g (f x) / g y₀ := by |
| exact local_equation_ratio_unit (hg (f x)) (hg y₀) |
| (hDg (f x)) (hDg y₀) (image_generic_mem f (hyU (f x))) (hyU y₀) |
| choose a ha heq using hlocal |
| let c : PrimeDivisor C → ℤ := fun p => C.ord (f.stalkMap (genericPoint C) (a p.1)) p.1 |
| have hc (p : PrimeDivisor C) (x : C) (hp : f p.1 ∈ U (f x)) : |
| c p = C.ord (f.stalkMap (genericPoint C) (a x)) p.1 := by |
| exact curve_equation_order_eq f (hg (f p.1)) (hg (f x)) (hg y₀) |
| (hDg (f p.1)) (hDg (f x)) (a p.1) (a x) (ha x) |
| (heq p.1) (heq x) p (hyU (f p.1)) hp |
| have ha₀ : a (genericPoint C) = 1 := by |
| apply IsFractionRing.injective (Y.presheaf.stalk y₀) Y.functionField |
| rw [heq, map_one] |
| exact div_self (hg y₀) |
| let V : C.Opens := f ⁻¹ᵁ U y₀ |
| have hV : (V : Set C)ᶜ ≠ Set.univ := by |
| intro h |
| have hm : genericPoint C ∈ (V : Set C)ᶜ := by rw [h]; trivial |
| exact hm (hyU y₀) |
| have hfinite : (Function.support c).Finite := by |
| apply (finite_primeDivisors_in_closed V.isOpen.isClosed_compl hV).subset |
| intro p hp hpV |
| apply hp |
| rw [hc p (genericPoint C) hpV, ha₀, map_one, order_one] |
| let E : WeilDivisor C := Finsupp.ofSupportFinite c hfinite |
| refine ⟨E, U y₀, hU y₀, hyU y₀, g y₀, hg y₀, hDg y₀, ?_⟩ |
| intro x |
| refine ⟨U (f x), hU (f x), hyU (f x), g (f x), hg (f x), hDg (f x), |
| a x, ha x, heq x, ?_⟩ |
| exact fun p hp => hc p x hp |
|
|
| theorem IsPulledCartierRepresentative.isCartier {C Y : Scheme} [IsIntegral C] [IsIntegral Y] |
| [IsLocallyNoetherian C] [IsLocallyNoetherian Y] |
| {f : C ⟶ Y} {D : WeilDivisor Y} {E : WeilDivisor C} |
| (hE : IsPulledCartierRepresentative f D E) : IsCartierDivisor E := by |
| obtain ⟨_, _, _, _, _, _, hlocal⟩ := hE |
| intro x |
| obtain ⟨V, _, hxV, _, _, _, a, ha, _, hEa⟩ := hlocal x |
| obtain ⟨W, hW, hxW, hWV⟩ := exists_isAffineOpen_mem_and_subset |
| (show x ∈ f ⁻¹ᵁ V from hxV) |
| refine ⟨W, hW, hxW, f.stalkMap (genericPoint C) a, |
| (ha.map (f.stalkMap (genericPoint C)).hom).ne_zero, ?_⟩ |
| exact fun p hp => hEa p (hWV hp) |
| end NumericalDimensionOne |
|
|
| open AlgebraicGeometry CategoryTheory |
|
|
| namespace NumericalDimensionOne |
|
|
| attribute [local instance] MvPolynomial.gradedAlgebra |
|
|
| noncomputable def complexProjectiveSpace (N : ℕ) : Scheme := |
| Proj (MvPolynomial.homogeneousSubmodule (Fin (N + 1)) ℂ) |
|
|
| noncomputable def projectiveConstants (N : ℕ) : |
| ℂ →+* (MvPolynomial.homogeneousSubmodule (Fin (N + 1)) ℂ 0) where |
| toFun a := ⟨MvPolynomial.C a, MvPolynomial.isHomogeneous_C (Fin (N + 1)) a⟩ |
| 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 complexProjectiveSpaceMap (N : ℕ) : |
| complexProjectiveSpace N ⟶ Spec (.of ℂ) := |
| Proj.toSpecZero (MvPolynomial.homogeneousSubmodule (Fin (N + 1)) ℂ) ≫ |
| Spec.map (CommRingCat.ofHom (projectiveConstants N)) |
|
|
| def IsComplexProjective {X : Scheme} (sX : X ⟶ Spec (.of ℂ)) : Prop := |
| ∃ N : ℕ, ∃ i : X ⟶ complexProjectiveSpace N, |
| IsClosedImmersion i ∧ i ≫ complexProjectiveSpaceMap N = sX |
|
|
| structure ComplexProjectiveVariety where |
| scheme : Scheme |
| structureMap : scheme ⟶ Spec (.of ℂ) |
| integral : IsIntegral scheme |
| connected : ConnectedSpace scheme |
| projective : IsComplexProjective structureMap |
|
|
| attribute [instance] ComplexProjectiveVariety.integral ComplexProjectiveVariety.connected |
|
|
| def IsSmoothNfold (X : ComplexProjectiveVariety) (n : ℕ) : Prop := |
| SmoothOfRelativeDimension n X.structureMap |
|
|
| theorem projectiveConstants_bijective (N : ℕ) : |
| Function.Bijective (projectiveConstants N) := by |
| constructor |
| · intro a b hab |
| exact MvPolynomial.C_injective (Fin (N + 1)) ℂ (congrArg Subtype.val hab) |
| · intro p |
| refine ⟨p.val.coeff 0, Subtype.ext ?_⟩ |
| exact ((MvPolynomial.totalDegree_eq_zero_iff_eq_C).mp |
| ((MvPolynomial.totalDegree_zero_iff_isHomogeneous (Fin (N + 1))).mpr p.property)).symm |
|
|
| theorem complexProjectiveSpace_isProper (N : ℕ) : |
| IsProper (complexProjectiveSpaceMap N) := by |
| let A := MvPolynomial.homogeneousSubmodule (Fin (N + 1)) ℂ |
| let : IsScalarTower ℂ (A 0) (MvPolynomial (Fin (N + 1)) ℂ) := |
| IsScalarTower.of_algebraMap_eq (R := ℂ) (S := A 0) (A := MvPolynomial (Fin (N + 1)) ℂ) fun _ => rfl |
| let : Algebra.FiniteType (A 0) (MvPolynomial (Fin (N + 1)) ℂ) := |
| Algebra.FiniteType.of_restrictScalars_finiteType ℂ (A 0) |
| (MvPolynomial (Fin (N + 1)) ℂ) |
| let e := RingEquiv.ofBijective (projectiveConstants N) (projectiveConstants_bijective N) |
| let : IsIso (CommRingCat.ofHom (projectiveConstants N)) := by |
| exact e.toCommRingCatIso.isIso_hom |
| have hp : IsProper (Proj.toSpecZero A) := inferInstance |
| have he : IsIso (Spec.map (CommRingCat.ofHom (projectiveConstants N))) := inferInstance |
| let := hp |
| let := he |
| change IsProper (Proj.toSpecZero A ≫ |
| Spec.map (CommRingCat.ofHom (projectiveConstants N))) |
| let ht : IsProper (Spec.map (CommRingCat.ofHom (projectiveConstants N))) := inferInstance |
| exact IsProper.comp_iff.mpr hp |
|
|
| theorem isProper_of_isComplexProjective {X : Scheme} (sX : X ⟶ Spec (.of ℂ)) |
| (hX : IsComplexProjective sX) : IsProper sX := by |
| obtain ⟨N, i, hi, rfl⟩ := hX |
| let := hi |
| let := complexProjectiveSpace_isProper N |
| infer_instance |
|
|
| end NumericalDimensionOne |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
|
|
| namespace NumericalDimensionOne |
|
|
| 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 NumericalDimensionOne |
|
|
| open AlgebraicGeometry CategoryTheory |
| open scoped TensorProduct nonZeroDivisors |
| open scoped TensorProduct |
|
|
| namespace NumericalDimensionOne |
|
|
| section TopDifferentials |
| variable (k A B : Type*) [CommRing k] [CommRing A] [CommRing B] |
| [Algebra k A] [Algebra k B] [Algebra A B] [IsScalarTower k A B] |
|
|
| def alternatingRestrictScalars {M N ι : Type*} |
| [AddCommGroup M] [AddCommGroup N] [Module A M] [Module A N] |
| [Module B M] [Module B N] [IsScalarTower A B M] [IsScalarTower A B N] |
| (f : M [⋀^ι]→ₗ[B] N) : M [⋀^ι]→ₗ[A] N where |
| toMultilinearMap := f.toMultilinearMap.restrictScalars A |
| map_eq_zero_of_eq' := f.map_eq_zero_of_eq |
|
|
| noncomputable def topDifferentialMap (n : ℕ) : |
| (⋀[A]^n Ω[A⁄k]) →ₗ[A] (⋀[B]^n Ω[B⁄k]) := |
| exteriorPower.alternatingMapLinearEquiv |
| ((alternatingRestrictScalars A B (exteriorPower.ιMulti B n)).compLinearMap |
| (KaehlerDifferential.map k k A B)) |
|
|
| @[simp] theorem topDifferentialMap_ιMulti (n : ℕ) (v : Fin n → Ω[A⁄k]) : |
| topDifferentialMap k A B n (exteriorPower.ιMulti A n v) = |
| exteriorPower.ιMulti B n (fun i => KaehlerDifferential.map k k A B (v i)) := by |
| simp [topDifferentialMap, alternatingRestrictScalars, |
| AlternatingMap.compLinearMap_apply] |
| rfl |
|
|
| end TopDifferentials |
|
|
| section SchemeScalars |
| universe u |
| variable (k : CommRingCat.{u}) {X : Scheme.{u}} [IsIntegral X] |
|
|
| noncomputable def schemeStalkScalar (sX : X ⟶ Spec k) (x : X) : |
| k →+* X.presheaf.stalk x := |
| (X.presheaf.germ ⊤ x (by trivial)).hom.comp |
| (sX.appTop.hom.comp (Scheme.ΓSpecIso k).inv.hom) |
|
|
| noncomputable def schemeFieldScalar (sX : X ⟶ Spec k) : k →+* X.functionField := |
| (X.germToFunctionField ⊤).hom.comp |
| (sX.appTop.hom.comp (Scheme.ΓSpecIso k).inv.hom) |
|
|
| @[instance_reducible] |
| noncomputable def schemeStalkAlgebra (sX : X ⟶ Spec k) (x : X) : |
| Algebra k (X.presheaf.stalk x) := (schemeStalkScalar k sX x).toAlgebra |
|
|
| @[instance_reducible] |
| noncomputable def schemeFieldAlgebra (sX : X ⟶ Spec k) : Algebra k X.functionField := |
| (schemeFieldScalar k sX).toAlgebra |
|
|
| theorem stalk_field_scalar_tower (sX : X ⟶ Spec k) (x : X) : |
| letI := schemeStalkAlgebra k sX x |
| letI := schemeFieldAlgebra k sX |
| IsScalarTower k (X.presheaf.stalk x) X.functionField := by |
| let := schemeStalkAlgebra k sX x |
| let := schemeFieldAlgebra k sX |
| apply IsScalarTower.of_algebraMap_eq |
| intro a |
| exact (X.algebraMap_germ_eq_germToFunctionField (by trivial) |
| (sX.appTop ((Scheme.ΓSpecIso k).inv a))).symm |
|
|
| end SchemeScalars |
| end NumericalDimensionOne |
|
|
| end OAI |
|
|
