| import Mathlib | |
| import OAI.AlgebraicGeometry.NumericalDimension.CanonicalExistence | |
| namespace OAI | |
| /-! Differential Base Change. -/ | |
| open AlgebraicGeometry CategoryTheory | |
| open scoped TensorProduct nonZeroDivisors | |
| open scoped TensorProduct | |
| open AlgebraicGeometry CategoryTheory TopologicalSpace | |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace | |
| namespace NumericalDimensionOne | |
| open AlgebraicGeometry CategoryTheory | |
| section | |
| variable {X Y Z : Scheme} [IsIntegral X] [IsIntegral Y] [IsIntegral Z] | |
| [IsLocallyNoetherian X] [IsLocallyNoetherian Y] [IsLocallyNoetherian Z] | |
| private lemma IsCartierPullback.nsmul_local {morphism : X ⟶ Y} [IsDominant morphism] | |
| {divisor : WeilDivisor Y} {pullback : WeilDivisor X} | |
| (pullback_spec : IsCartierPullback morphism divisor pullback) (multiple : ℕ) : | |
| IsCartierPullback morphism (multiple • divisor) (multiple • pullback) := by | |
| induction multiple with | |
| | zero => simpa using isCartierPullback_zero morphism | |
| | succ multiple induction_hypothesis => | |
| simpa only [succ_nsmul] using induction_hypothesis.add pullback_spec | |
| lemma IsCartierPullback.eq_ord_on_open [StalkwiseNormal Y] | |
| {f : X ⟶ Y} [IsDominant f] {D : WeilDivisor Y} {E : WeilDivisor X} | |
| (hE : IsCartierPullback f D E) {U : Y.Opens} {a : Y.functionField} | |
| (ha : a ≠ 0) (hDa : ∀ p : PrimeDivisor Y, p.1 ∈ U → D p = Y.ord a p.1) | |
| (p : PrimeDivisor X) (hp : f p.1 ∈ U) : | |
| E p = X.ord (dominantFunctionFieldMap f a) p.1 := by | |
| obtain ⟨V,_,hpV,b,hb,hDb,hEb⟩ := hE p.1 | |
| rw [hEb p hpV] | |
| exact pulled_equation_order_eq f hb ha hDb hDa p hpV hp | |
| lemma IsCartierPullback.comp [StalkwiseNormal Y] | |
| {f : X ⟶ Y} {g : Y ⟶ Z} [IsDominant f] [IsDominant g] | |
| {D : WeilDivisor Z} {E : WeilDivisor Y} {F : WeilDivisor X} | |
| (hg : IsCartierPullback g D E) (hf : IsCartierPullback f E F) : | |
| IsCartierPullback (f ≫ g) D F := by | |
| intro x | |
| obtain ⟨U,hU,hx,a,ha,hDa,hEa⟩ := hg (f x) | |
| refine ⟨U,hU,hx,a,ha,hDa,?_⟩ | |
| intro p hp | |
| rw [dominantFunctionFieldMap_comp_apply] | |
| exact hf.eq_ord_on_open ((map_ne_zero _).mpr ha) | |
| (U := g ⁻¹ᵁ U) (fun q hq => hEa q hq) p hp | |
| lemma IsQCartierPullback.comp [StalkwiseNormal Y] | |
| {f : X ⟶ Y} {g : Y ⟶ Z} [IsDominant f] [IsDominant g] | |
| {D : QWeilDivisor Z} {E : QWeilDivisor Y} {F : QWeilDivisor X} | |
| (hg : IsQCartierPullback g D E) (hf : IsQCartierPullback f E F) : | |
| IsQCartierPullback (f ≫ g) D F := by | |
| obtain ⟨m,hm,A,B,hA,hAD,hBE,hAB⟩ := hg | |
| obtain ⟨n,hn,C,G,_,hCE,hGF,hCG⟩ := hf | |
| have hBC : n • B = m • C := by | |
| ext p | |
| have hb := DFunLike.congr_fun hBE p | |
| have hc := DFunLike.congr_fun hCE p | |
| change (m : ℚ) * E p = (B p : ℚ) at hb | |
| change (n : ℚ) * E p = (C p : ℚ) at hc | |
| have he : (n : ℚ) * (B p : ℚ) = (m : ℚ) * (C p : ℚ) := by | |
| rw [← hb, ← hc]; ring | |
| change (n : ℤ) * B p = (m : ℤ) * C p | |
| exact_mod_cast he | |
| have hnf := hCG.nsmul_local m | |
| rw [← hBC] at hnf | |
| refine ⟨m*n,Nat.mul_pos hm hn,n • A,m • G, | |
| (cartierDivisors (X := Z)).nsmul_mem hA n,?_,?_,(hAB.nsmul_local n).comp hnf⟩ | |
| · ext p | |
| have h := DFunLike.congr_fun hAD p | |
| change (m : ℚ) * D p = (A p : ℚ) at h | |
| change ((m*n : ℕ) : ℚ) * D p = ((n : ℤ) * A p : ℤ) | |
| push_cast | |
| rw [← h] | |
| ring | |
| · ext p | |
| have h := DFunLike.congr_fun hGF p | |
| change (n : ℚ) * F p = (G p : ℚ) at h | |
| change ((m*n : ℕ) : ℚ) * F p = ((m : ℤ) * G p : ℤ) | |
| push_cast | |
| rw [← h] | |
| ring | |
| end | |
| end NumericalDimensionOne | |
| open AlgebraicGeometry CategoryTheory | |
| open scoped TensorProduct nonZeroDivisors | |
| open scoped TensorProduct | |
| open AlgebraicGeometry CategoryTheory TopologicalSpace | |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace | |
| namespace NumericalDimensionOne | |
| open AlgebraicGeometry CategoryTheory | |
| section | |
| variable {X Y : Scheme} [IsIntegral X] [IsIntegral Y] | |
| [IsLocallyNoetherian X] [IsLocallyNoetherian Y] | |
| lemma IsCartierPullback.nonneg [StalkwiseNormal X] [StalkwiseNormal Y] | |
| {f : X ⟶ Y} [IsDominant f] {D : WeilDivisor Y} {E : WeilDivisor X} | |
| (hE : IsCartierPullback f D E) (hD : 0 ≤ D) : 0 ≤ E := by | |
| intro p | |
| obtain ⟨U,hU,hp,a,ha,hDa,hEa⟩ := hE p.1 | |
| let : Nonempty U := ⟨⟨f p.1,hp⟩⟩ | |
| obtain ⟨b,hb⟩ := (affine_regular_iff_nonnegative_orders hU a).mpr | |
| (Or.inr (fun q hq => (hDa q hq) ▸ hD q)) | |
| rw [hEa p hp] | |
| apply (ord_nonnegative_iff_regular p _ ((map_ne_zero _).mpr ha)).mpr | |
| refine ⟨f.stalkMap p.1 (Y.presheaf.germ U (f p.1) hp b),?_⟩ | |
| rw [← dominantFunctionFieldMap_algebraMap, | |
| Y.algebraMap_germ_eq_germToFunctionField hp,hb] | |
| lemma IsQCartierPullback.isQCartier {f : X ⟶ Y} [IsDominant f] | |
| {D : QWeilDivisor Y} {E : QWeilDivisor X} (hE : IsQCartierPullback f D E) : | |
| IsQCartierDivisor E := by | |
| obtain ⟨m,hm,A,B,_,_,hB,hAB⟩ := hE | |
| exact ⟨m,hm,B,hAB.isCartier,hB⟩ | |
| lemma IsQCartierPullback.nonneg [StalkwiseNormal X] [StalkwiseNormal Y] | |
| {f : X ⟶ Y} [IsDominant f] {D : QWeilDivisor Y} {E : QWeilDivisor X} | |
| (hE : IsQCartierPullback f D E) (hD : 0 ≤ D) : 0 ≤ E := by | |
| obtain ⟨m,hm,A,B,_,hA,hB,hAB⟩ := hE | |
| have hApos : 0 ≤ A := by | |
| intro p | |
| have h := DFunLike.congr_fun hA p | |
| change (m : ℚ) * D p = (A p : ℚ) at h | |
| have hp : 0 ≤ (A p : ℚ) := h ▸ mul_nonneg (Nat.cast_nonneg m) (hD p) | |
| exact_mod_cast hp | |
| have hBpos := hAB.nonneg hApos | |
| intro p | |
| have h := DFunLike.congr_fun hB p | |
| change (m : ℚ) * E p = (B p : ℚ) at h | |
| have hp : 0 ≤ (B p : ℚ) := by exact_mod_cast hBpos p | |
| rw [← h] at hp | |
| exact nonneg_of_mul_nonneg_right hp (by exact_mod_cast hm) | |
| lemma IsQCartierPullback.unique [StalkwiseNormal Y] | |
| {f : X ⟶ Y} [IsDominant f] {D : QWeilDivisor Y} {E F : QWeilDivisor X} | |
| (hE : IsQCartierPullback f D E) (hF : IsQCartierPullback f D F) : E = F := by | |
| obtain ⟨m,hm,A,B,_,hAD,hBE,hAB⟩ := hE | |
| obtain ⟨n,hn,C,G,_,hCD,hGF,hCG⟩ := hF | |
| have hAC : n • A = m • C := by | |
| ext p | |
| have ha := DFunLike.congr_fun hAD p | |
| have hc := DFunLike.congr_fun hCD p | |
| change (m : ℚ) * D p = (A p : ℚ) at ha | |
| change (n : ℚ) * D p = (C p : ℚ) at hc | |
| have he : (n : ℚ) * (A p : ℚ) = (m : ℚ) * (C p : ℚ) := by | |
| rw [← ha, ← hc]; ring | |
| change (n : ℤ) * A p = (m : ℤ) * C p | |
| exact_mod_cast he | |
| have hc := hCG.nsmul_local m | |
| rw [← hAC] at hc | |
| have hBG := (hAB.nsmul_local n).unique hc | |
| ext p | |
| have hb := DFunLike.congr_fun hBE p | |
| have hg := DFunLike.congr_fun hGF p | |
| have he := DFunLike.congr_fun hBG p | |
| change (m : ℚ) * E p = (B p : ℚ) at hb | |
| change (n : ℚ) * F p = (G p : ℚ) at hg | |
| change (n : ℤ) * B p = (m : ℤ) * G p at he | |
| have he' : (n : ℚ) * (B p : ℚ) = (m : ℚ) * (G p : ℚ) := by exact_mod_cast he | |
| apply mul_left_cancel₀ (mul_ne_zero (Nat.cast_ne_zero.mpr (Nat.ne_of_gt hm)) | |
| (Nat.cast_ne_zero.mpr (Nat.ne_of_gt hn))) | |
| calc | |
| (m : ℚ) * (n : ℚ) * E p = (n : ℚ) * (B p : ℚ) := by rw [← hb]; ring | |
| _ = (m : ℚ) * (G p : ℚ) := he' | |
| _ = (m : ℚ) * (n : ℚ) * F p := by rw [← hg]; ring | |
| end | |
| end NumericalDimensionOne | |
| open AlgebraicGeometry CategoryTheory | |
| open scoped TensorProduct nonZeroDivisors | |
| open scoped TensorProduct | |
| open AlgebraicGeometry CategoryTheory TopologicalSpace | |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace | |
| namespace NumericalDimensionOne | |
| open AlgebraicGeometry CategoryTheory | |
| lemma IsCartierDivisor.pullback_id {X : Scheme} [IsIntegral X] [IsLocallyNoetherian X] | |
| {D : WeilDivisor X} (hD : IsCartierDivisor D) : IsCartierPullback (𝟙 X) D D := by | |
| intro x | |
| obtain ⟨U,hU,hx,g,hg,he⟩ := hD x | |
| refine ⟨U,hU,hx,g,hg,he,?_⟩ | |
| intro p hp | |
| rw [dominantFunctionFieldMap_id_apply] | |
| exact he p hp | |
| lemma IsQCartierDivisor.pullback_id {X : Scheme} [IsIntegral X] [IsLocallyNoetherian X] | |
| {D : QWeilDivisor X} (hD : IsQCartierDivisor D) : IsQCartierPullback (𝟙 X) D D := by | |
| obtain ⟨m,hm,A,hA,he⟩ := hD | |
| exact ⟨m,hm,A,A,hA,he,he,hA.pullback_id⟩ | |
| lemma HasEffectiveCanonicalComparison.refl {n : ℕ} (X : CanonicalModel n) | |
| (hX : IsSmoothNfold X.toComplexProjectiveVariety n) : | |
| HasEffectiveCanonicalComparison X X (.refl X.scheme) := by | |
| have hφ : (Scheme.PartialIso.refl X.scheme).IsOver (𝟙 X.scheme) (𝟙 X.scheme) := | |
| Category.id_comp _ | |
| refine ⟨X.toComplexProjectiveVariety,hX,𝟙 X.scheme,𝟙 X.scheme, | |
| inferInstance,inferInstance,inferInstance,inferInstance,Category.id_comp _,Category.id_comp _, | |
| .refl X.scheme,hφ,hφ.trans hφ,rationalWeilDivisor X.canonical, | |
| rationalWeilDivisor X.canonical,0,X.qCartier.pullback_id,X.qCartier.pullback_id, | |
| (add_zero _).symm,le_refl _,?_,?_⟩ | |
| · intro F hF | |
| exact (hF rfl).elim | |
| · intro F hF hF' | |
| exact (not_lt_of_ge hF.le hF').elim | |
| end NumericalDimensionOne | |
| open AlgebraicGeometry CategoryTheory | |
| open scoped TensorProduct nonZeroDivisors | |
| open scoped TensorProduct | |
| open AlgebraicGeometry CategoryTheory TopologicalSpace | |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace | |
| namespace NumericalDimensionOne | |
| section CanonicalChartEquation | |
| universe u | |
| variable {k : Type u} [Field k] {Y : Scheme.{u}} [IsIntegral Y] | |
| [IsLocallyNoetherian Y] | |
| lemma canonical_chart_equation (sY : Y ⟶ Spec (.of k)) (n : ℕ) | |
| {ω : rationalTopForms (.of k) sY n} {D : WeilDivisor Y} | |
| (hD : IsCanonicalDivisorOf (.of k) sY n ω D) | |
| (U : Y.Opens) (hU : IsAffineOpen U) [Nonempty U] : | |
| letI := schemeOpenAlgebra sY U | |
| letI := schemeFieldAlgebra (.of k) sY | |
| letI := open_field_scalar_tower sY U | |
| ∀ (_ : Algebra.IsStandardSmoothOfRelativeDimension n k Γ(Y, U)) | |
| (bU : Module.Basis (Fin 1) Γ(Y, U) (⋀[Γ(Y, U)]^n Ω[Γ(Y, U)⁄k])) | |
| (a : Y.functionField), a ≠ 0 → | |
| ω = a • topDifferentialMap k Γ(Y, U) Y.functionField n (bU 0) → | |
| ∀ p : PrimeDivisor Y, p.1 ∈ U → D p = Y.ord a p.1 := by | |
| let := schemeOpenAlgebra sY U | |
| let := schemeFieldAlgebra (.of k) sY | |
| let := open_field_scalar_tower sY U | |
| intro hs bU a ha heq p hp | |
| let : Algebra.IsStandardSmoothOfRelativeDimension n k Γ(Y, U) := hs | |
| let : Algebra.IsStandardSmooth k Γ(Y, U) := | |
| Algebra.IsStandardSmoothOfRelativeDimension.isStandardSmooth n | |
| let := schemeStalkAlgebra (.of k) sY p.1 | |
| let := stalk_field_scalar_tower (.of k) sY p.1 | |
| let y : U := ⟨p.1, hp⟩ | |
| let := TopCat.Presheaf.algebra_section_stalk Y.presheaf y | |
| let := open_stalk_scalar_tower sY U y | |
| let := functionField_isScalarTower Y U y | |
| let := hU.isLocalization_stalk y | |
| let : Algebra.FormallyEtale Γ(Y, U) (Y.presheaf.stalk p.1) := | |
| Algebra.FormallyEtale.of_isLocalization (hU.primeIdealOf y).asIdeal.primeCompl | |
| let bp := (topDifferential_isBaseChange k Γ(Y, U) (Y.presheaf.stalk p.1) n).basis bU | |
| have heqp : ω = a • topDifferentialMap k (Y.presheaf.stalk p.1) Y.functionField n (bp 0) := by | |
| rw [(topDifferential_isBaseChange k Γ(Y, U) (Y.presheaf.stalk p.1) n).basis_apply] | |
| exact heq.trans (congrArg (fun v => a • v) | |
| (LinearMap.congr_fun (topDifferentialMap_comp k Γ(Y, U) | |
| (Y.presheaf.stalk p.1) Y.functionField n) (bU 0)).symm) | |
| obtain ⟨cp, a', ha', hc, hDa'⟩ := hD.2 p | |
| rw [hDa'] | |
| exact canonical_local_order_unique sY n p ω cp bp a' a hD.1 ha' ha hc heqp | |
| end CanonicalChartEquation | |
| end NumericalDimensionOne | |
| open AlgebraicGeometry CategoryTheory | |
| open scoped TensorProduct nonZeroDivisors | |
| open scoped TensorProduct | |
| open AlgebraicGeometry CategoryTheory TopologicalSpace | |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace | |
| namespace NumericalDimensionOne | |
| lemma dominant_stalk_scalar | |
| {X Y : Scheme} [IsIntegral X] [IsIntegral Y] | |
| (k : CommRingCat) (sX : X ⟶ Spec k) (sY : Y ⟶ Spec k) | |
| (f : X ⟶ Y) [IsDominant f] (hf : f ≫ sY = sX) (x : X) (a : k) : | |
| f.stalkMap x (schemeStalkScalar k sY (f x) a) = schemeStalkScalar k sX x a := by | |
| apply IsFractionRing.injective (X.presheaf.stalk x) X.functionField | |
| rw [← dominantFunctionFieldMap_algebraMap] | |
| have hY := X.algebraMap_germ_eq_germToFunctionField (by trivial : x ∈ (⊤ : X.Opens)) | |
| (sX.appTop ((Scheme.ΓSpecIso k).inv a)) | |
| have hX := Y.algebraMap_germ_eq_germToFunctionField (by trivial : f x ∈ (⊤ : Y.Opens)) | |
| (sY.appTop ((Scheme.ΓSpecIso k).inv a)) | |
| change dominantFunctionFieldMap f | |
| (algebraMap (Y.presheaf.stalk (f x)) Y.functionField | |
| (Y.presheaf.germ ⊤ (f x) (by trivial) (sY.appTop ((Scheme.ΓSpecIso k).inv a)))) = | |
| algebraMap (X.presheaf.stalk x) X.functionField | |
| (X.presheaf.germ ⊤ x (by trivial) (sX.appTop ((Scheme.ΓSpecIso k).inv a))) | |
| rw [hX, hY] | |
| exact dominantFunctionFieldMap_scalar k sX sY f hf a | |
| end NumericalDimensionOne | |
| open AlgebraicGeometry CategoryTheory | |
| open scoped TensorProduct nonZeroDivisors | |
| open scoped TensorProduct | |
| open AlgebraicGeometry CategoryTheory TopologicalSpace | |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace | |
| namespace NumericalDimensionOne | |
| theorem smooth_relative_canonical_effective | |
| (X Y : ComplexProjectiveVariety) (n : ℕ) | |
| (hX : IsSmoothNfold X n) (hY : IsSmoothNfold Y n) | |
| (f : X.scheme ⟶ Y.scheme) [IsDominant f] | |
| (hf : f ≫ Y.structureMap = X.structureMap) | |
| (ω : rationalTopForms (.of ℂ) Y.structureMap n) | |
| (DX : WeilDivisor X.scheme) (DY : WeilDivisor Y.scheme) | |
| (hDX : IsCanonicalDivisorOf (.of ℂ) X.structureMap n | |
| (rationalTopFormPullback (.of ℂ) X.structureMap Y.structureMap f hf n ω) DX) | |
| (hDY : IsCanonicalDivisorOf (.of ℂ) Y.structureMap n ω DY) | |
| (P : WeilDivisor X.scheme) (hP : IsCartierPullback f DY P) : | |
| 0 ≤ DX - P := by | |
| classical | |
| let : SmoothOfRelativeDimension n X.structureMap := hX | |
| let : SmoothOfRelativeDimension n Y.structureMap := hY | |
| let : StalkwiseNormal X.scheme := smoothNormal X hX | |
| let : StalkwiseNormal Y.scheme := smoothNormal Y hY | |
| let := schemeFieldAlgebra (.of ℂ) X.structureMap | |
| let := schemeFieldAlgebra (.of ℂ) Y.structureMap | |
| let : Algebra Y.scheme.functionField X.scheme.functionField := | |
| (dominantFunctionFieldMap f).toAlgebra | |
| let : IsScalarTower ℂ Y.scheme.functionField X.scheme.functionField := | |
| IsScalarTower.of_algebraMap_eq (fun a => | |
| (dominantFunctionFieldMap_scalar (.of ℂ) X.structureMap Y.structureMap f hf a).symm) | |
| intro p | |
| change 0 ≤ DX p - P p | |
| obtain ⟨U, hU, hpU, hs⟩ := exists_standard_smooth_chart Y.structureMap n (f p.1) | |
| let : Nonempty U := ⟨⟨f p.1, hpU⟩⟩ | |
| let := schemeOpenAlgebra Y.structureMap U | |
| let : Algebra.IsStandardSmoothOfRelativeDimension n ℂ Γ(Y.scheme, U) := hs | |
| let : Algebra.IsStandardSmooth ℂ Γ(Y.scheme, U) := | |
| Algebra.IsStandardSmoothOfRelativeDimension.isStandardSmooth n | |
| let := open_field_scalar_tower Y.structureMap U | |
| let := functionField_isFractionRing_of_isAffineOpen Y.scheme U hU | |
| let : Algebra.FormallyEtale Γ(Y.scheme, U) Y.scheme.functionField := | |
| Algebra.FormallyEtale.of_isLocalization (nonZeroDivisors Γ(Y.scheme, U)) | |
| obtain ⟨bU⟩ := nonempty_topDifferential_basis ℂ Γ(Y.scheme, U) n | |
| let bF := (topDifferential_isBaseChange ℂ Γ(Y.scheme, U) Y.scheme.functionField n).basis bU | |
| let a := bF.repr ω 0 | |
| have heq : ω = a • topDifferentialMap ℂ Γ(Y.scheme, U) Y.scheme.functionField n (bU 0) := by | |
| simpa only [bF, IsBaseChange.basis_apply] using basis_singleton_repr bF ω | |
| have ha : a ≠ 0 := by | |
| intro h | |
| exact hDY.1 (by simpa [h] using heq) | |
| have hDa := canonical_chart_equation Y.structureMap n hDY U hU hs bU a ha heq | |
| have hPa := hP.eq_ord_on_open ha hDa p hpU | |
| let := schemeStalkAlgebra (.of ℂ) X.structureMap p.1 | |
| let := stalk_field_scalar_tower (.of ℂ) X.structureMap p.1 | |
| let u : U := ⟨f p.1, hpU⟩ | |
| let := schemeStalkAlgebra (.of ℂ) Y.structureMap (f p.1) | |
| let := TopCat.Presheaf.algebra_section_stalk Y.scheme.presheaf u | |
| let := open_stalk_scalar_tower Y.structureMap U u | |
| let : Algebra Γ(Y.scheme, U) (X.scheme.presheaf.stalk p.1) := | |
| ((f.stalkMap p.1).hom.comp (Y.scheme.presheaf.germ U (f p.1) hpU).hom).toAlgebra | |
| let : IsScalarTower ℂ Γ(Y.scheme, U) (X.scheme.presheaf.stalk p.1) := by | |
| apply IsScalarTower.of_algebraMap_eq | |
| intro z | |
| change schemeStalkScalar (.of ℂ) X.structureMap p.1 z = | |
| f.stalkMap p.1 (algebraMap Γ(Y.scheme, U) (Y.scheme.presheaf.stalk (f p.1)) | |
| (algebraMap ℂ Γ(Y.scheme, U) z)) | |
| rw [← IsScalarTower.algebraMap_apply] | |
| exact (dominant_stalk_scalar (.of ℂ) X.structureMap Y.structureMap f hf p.1 z).symm | |
| let : Algebra Γ(Y.scheme, U) X.scheme.functionField := | |
| ((dominantFunctionFieldMap f).comp (Y.scheme.germToFunctionField U).hom).toAlgebra | |
| let : IsScalarTower Γ(Y.scheme, U) Y.scheme.functionField X.scheme.functionField := by | |
| apply IsScalarTower.of_algebraMap_eq | |
| intro z | |
| rfl | |
| let : IsScalarTower ℂ Γ(Y.scheme, U) X.scheme.functionField := by | |
| apply IsScalarTower.of_algebraMap_eq | |
| intro z | |
| change algebraMap ℂ X.scheme.functionField z = | |
| dominantFunctionFieldMap f | |
| (algebraMap Γ(Y.scheme, U) Y.scheme.functionField (algebraMap ℂ Γ(Y.scheme, U) z)) | |
| rw [← IsScalarTower.algebraMap_apply] | |
| exact (dominantFunctionFieldMap_scalar (.of ℂ) X.structureMap Y.structureMap f hf z).symm | |
| let : IsScalarTower Γ(Y.scheme, U) (X.scheme.presheaf.stalk p.1) X.scheme.functionField := by | |
| apply IsScalarTower.of_algebraMap_eq | |
| intro z | |
| change dominantFunctionFieldMap f (Y.scheme.germToFunctionField U z) = | |
| algebraMap (X.scheme.presheaf.stalk p.1) X.scheme.functionField | |
| (f.stalkMap p.1 (Y.scheme.presheaf.germ U (f p.1) hpU z)) | |
| rw [← dominantFunctionFieldMap_algebraMap, Y.scheme.algebraMap_germ_eq_germToFunctionField] | |
| obtain ⟨bp⟩ := nonempty_smooth_canonical_stalk_basis X.structureMap n p.1 | |
| let v := topDifferentialMap ℂ Γ(Y.scheme, U) (X.scheme.presheaf.stalk p.1) n (bU 0) | |
| let c := bp.repr v 0 | |
| have hc : v = c • bp 0 := basis_singleton_repr bp v | |
| dsimp only [v] at hc | |
| let cf := algebraMap (X.scheme.presheaf.stalk p.1) X.scheme.functionField c | |
| have hpull : rationalTopFormPullback (.of ℂ) X.structureMap Y.structureMap f hf n ω = | |
| (dominantFunctionFieldMap f a * cf) • | |
| topDifferentialMap ℂ (X.scheme.presheaf.stalk p.1) X.scheme.functionField n (bp 0) := by | |
| change topDifferentialMap ℂ Y.scheme.functionField X.scheme.functionField n ω = _ | |
| rw [heq, map_smul, ← IsScalarTower.algebraMap_smul X.scheme.functionField a] | |
| have hcomp₁ := LinearMap.congr_fun (topDifferentialMap_comp ℂ Γ(Y.scheme, U) | |
| Y.scheme.functionField X.scheme.functionField n) (bU 0) | |
| have hcomp₂ := LinearMap.congr_fun (topDifferentialMap_comp ℂ Γ(Y.scheme, U) | |
| (X.scheme.presheaf.stalk p.1) X.scheme.functionField n) (bU 0) | |
| simp only [LinearMap.comp_apply, LinearMap.restrictScalars_apply] at hcomp₁ hcomp₂ | |
| change _ • _ = _ | |
| rw [hcomp₁, ← hcomp₂, hc, map_smul, | |
| ← IsScalarTower.algebraMap_smul X.scheme.functionField c, ← mul_smul] | |
| rfl | |
| have hprod : dominantFunctionFieldMap f a * cf ≠ 0 := by | |
| intro h | |
| exact hDX.1 (by simpa [h] using hpull) | |
| have hcf : cf ≠ 0 := (mul_ne_zero_iff.mp hprod).2 | |
| obtain ⟨cp, a', ha', heq', hDXp⟩ := hDX.2 p | |
| have hDXord := canonical_local_order_unique X.structureMap n p _ cp bp a' | |
| (dominantFunctionFieldMap f a * cf) hDX.1 ha' hprod heq' hpull | |
| rw [hDXp, hDXord, X.scheme.ord_mul ((map_ne_zero _).mpr ha) hcf, hPa] | |
| have hcpos : 0 ≤ X.scheme.ord cf p.1 := | |
| (ord_nonnegative_iff_regular p cf hcf).mpr ⟨c, rfl⟩ | |
| omega | |
| end NumericalDimensionOne | |
| open AlgebraicGeometry CategoryTheory | |
| open scoped TensorProduct nonZeroDivisors | |
| open scoped TensorProduct | |
| open AlgebraicGeometry CategoryTheory TopologicalSpace | |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace | |
| namespace NumericalDimensionOne | |
| lemma exterior_volume_spans | |
| {R M : Type*} [CommRing R] [AddCommGroup M] [Module R M] | |
| {n : ℕ} (b : Module.Basis (Fin n) R M) (x : ⋀[R]^n M) : | |
| ∃ c : R, x = c • exteriorPower.ιMulti R n b := by | |
| classical | |
| have h : (exteriorPower.ιMulti R n : M [⋀^Fin n]→ₗ[R] (⋀[R]^n M)) = | |
| b.det.smulRight (exteriorPower.ιMulti R n b) := by | |
| apply b.ext_alternating | |
| intro i hi | |
| let σ : Equiv.Perm (Fin n) := Equiv.ofBijective i (Finite.injective_iff_bijective.mp hi) | |
| change exteriorPower.ιMulti R n (b ∘ σ) = | |
| b.det.smulRight (exteriorPower.ιMulti R n b) (b ∘ σ) | |
| simp [AlternatingMap.map_perm, AlternatingMap.smulRight_apply, Module.Basis.det_self] | |
| have hx : x ∈ Submodule.span R {exteriorPower.ιMulti R n b} := by | |
| have hr : Submodule.span R (Set.range (exteriorPower.ιMulti R n (M := M))) ≤ | |
| Submodule.span R {exteriorPower.ιMulti R n b} := by | |
| rw [Submodule.span_le] | |
| rintro _ ⟨v, rfl⟩ | |
| rw [DFunLike.congr_fun h v] | |
| exact Submodule.smul_mem _ _ (Submodule.subset_span (by simp)) | |
| rw [exteriorPower.ιMulti_span] at hr | |
| exact hr (Submodule.mem_top) | |
| obtain ⟨c, hc⟩ := Submodule.mem_span_singleton.mp hx | |
| exact ⟨c, hc.symm⟩ | |
| end NumericalDimensionOne | |
| open AlgebraicGeometry CategoryTheory | |
| open scoped TensorProduct nonZeroDivisors | |
| open scoped TensorProduct | |
| open AlgebraicGeometry CategoryTheory TopologicalSpace | |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace | |
| namespace NumericalDimensionOne | |
| theorem formallyUnramified_of_topDifferential_unit | |
| (k A B : Type*) [CommRing k] [CommRing A] [CommRing B] | |
| [Algebra k A] [Algebra k B] [Algebra A B] [IsScalarTower k A B] | |
| (n : ℕ) (bA : Module.Basis (Fin n) A Ω[A⁄k]) | |
| (bB : Module.Basis (Fin n) B Ω[B⁄k]) | |
| (b : Module.Basis (Fin 1) B (⋀[B]^n Ω[B⁄k])) | |
| (z : ⋀[A]^n Ω[A⁄k]) | |
| (hu : IsUnit (b.repr (topDifferentialMap k A B n z) 0)) : | |
| Algebra.FormallyUnramified A B := by | |
| classical | |
| let f := KaehlerDifferential.map k k A B | |
| let d := exteriorPower.alternatingMapLinearEquiv bB.det | |
| have hb : IsUnit (d (b 0)) := by | |
| have hr : exteriorPower.ιMulti B n bB = | |
| b.repr (exteriorPower.ιMulti B n bB) 0 • b 0 := by | |
| simpa using (b.sum_repr (exteriorPower.ιMulti B n bB)).symm | |
| have he := congrArg d hr | |
| have hprod : b.repr (exteriorPower.ιMulti B n bB) 0 * d (b 0) = 1 := by | |
| simpa only [d, map_smul, exteriorPower.alternatingMapLinearEquiv_apply_ιMulti, | |
| Module.Basis.det_self, smul_eq_mul] using he.symm | |
| exact IsUnit.of_mul_eq_one _ (mul_comm _ _ |>.trans hprod) | |
| have hz : topDifferentialMap k A B n z = | |
| b.repr (topDifferentialMap k A B n z) 0 • b 0 := by | |
| simpa using (b.sum_repr (topDifferentialMap k A B n z)).symm | |
| have hdu : IsUnit (d (topDifferentialMap k A B n z)) := by | |
| rw [hz, map_smul, smul_eq_mul] | |
| exact hu.mul hb | |
| obtain ⟨a, rfl⟩ := exterior_volume_spans bA z | |
| have he : d (topDifferentialMap k A B n (a • exteriorPower.ιMulti A n bA)) = | |
| algebraMap A B a * bB.det (f ∘ bA) := by | |
| rw [map_smul, ← IsScalarTower.algebraMap_smul B a, | |
| topDifferentialMap_ιMulti, map_smul] | |
| simp only [d, exteriorPower.alternatingMapLinearEquiv_apply_ιMulti, smul_eq_mul] | |
| rfl | |
| rw [he] at hdu | |
| have hdet : IsUnit (bB.det (f ∘ bA)) := isUnit_of_mul_isUnit_right hdu | |
| have hspan := (bB.is_basis_iff_det.mpr hdet).2 | |
| have hle : Submodule.span B (Set.range (f ∘ bA)) ≤ | |
| LinearMap.range (KaehlerDifferential.mapBaseChange k A B) := by | |
| rw [Submodule.span_le] | |
| rintro _ ⟨i, rfl⟩ | |
| exact ⟨1 ⊗ₜ[A] bA i, by simp [f]⟩ | |
| rw [hspan] at hle | |
| have hs : Function.Surjective (KaehlerDifferential.mapBaseChange k A B) := | |
| LinearMap.range_eq_top.mp (top_le_iff.mp hle) | |
| constructor | |
| apply subsingleton_of_forall_eq 0 | |
| intro x | |
| obtain ⟨y, rfl⟩ := KaehlerDifferential.map_surjective k A B x | |
| exact (KaehlerDifferential.exact_mapBaseChange_map k A B y).mpr (hs y) | |
| end NumericalDimensionOne | |
| open AlgebraicGeometry CategoryTheory | |
| open scoped TensorProduct nonZeroDivisors | |
| open scoped TensorProduct | |
| open AlgebraicGeometry CategoryTheory TopologicalSpace | |
| open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace | |
| namespace NumericalDimensionOne | |
| theorem nonempty_standardSmooth_differential_basis (k A : Type*) | |
| [CommRing k] [CommRing A] [Algebra k A] [Nontrivial A] (n : ℕ) | |
| [Algebra.IsStandardSmoothOfRelativeDimension n k A] : | |
| Nonempty (Module.Basis (Fin n) A Ω[A⁄k]) := by | |
| let : Algebra.IsStandardSmooth k A := | |
| Algebra.IsStandardSmoothOfRelativeDimension.isStandardSmooth n | |
| have h : Module.finrank A Ω[A⁄k] = n := | |
| Module.finrank_eq_of_rank_eq | |
| (Algebra.IsStandardSmoothOfRelativeDimension.rank_kaehlerDifferential n) | |
| exact ⟨(Module.finBasis A Ω[A⁄k]).reindex (finCongr h)⟩ | |
| universe u | |
| theorem nonempty_smooth_stalk_differential_basis | |
| {k : Type u} [Field k] {X : Scheme.{u}} | |
| (sX : X ⟶ Spec (.of k)) (n : ℕ) [SmoothOfRelativeDimension n sX] (x : X) : | |
| letI := schemeStalkAlgebra (.of k) sX x | |
| Nonempty (Module.Basis (Fin n) (X.presheaf.stalk x) Ω[X.presheaf.stalk x⁄k]) := by | |
| let := schemeStalkAlgebra (.of k) sX x | |
| obtain ⟨U, hU, hxU, hs⟩ := exists_standard_smooth_chart sX n x | |
| let y : U := ⟨x, hxU⟩ | |
| let : Nonempty U := ⟨y⟩ | |
| let := schemeOpenAlgebra sX U | |
| let : Algebra.IsStandardSmoothOfRelativeDimension n k Γ(X, U) := hs | |
| let : Algebra.IsStandardSmooth k Γ(X, U) := | |
| Algebra.IsStandardSmoothOfRelativeDimension.isStandardSmooth n | |
| let := TopCat.Presheaf.algebra_section_stalk X.presheaf y | |
| let := open_stalk_scalar_tower sX U y | |
| let := hU.isLocalization_stalk y | |
| let : Algebra.FormallyEtale Γ(X, U) (X.presheaf.stalk x) := | |
| Algebra.FormallyEtale.of_isLocalization (hU.primeIdealOf y).asIdeal.primeCompl | |
| obtain ⟨bU⟩ := nonempty_standardSmooth_differential_basis k Γ(X, U) n | |
| exact ⟨(KaehlerDifferential.isBaseChange_of_formallyEtale k Γ(X, U) | |
| (X.presheaf.stalk x)).basis bU⟩ | |
| end NumericalDimensionOne | |
| end OAI | |