| import Mathlib |
| import OAI.AlgebraicGeometry.NumericalDimension.OpenSections |
|
|
| namespace OAI |
|
|
| /-! Local Klt Members. -/ |
|
|
| 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 |
| variable {X : Scheme} [IsIntegral X] [IsLocallyNoetherian X] |
| {N : ℕ} {D : WeilDivisor X} {s : Fin (N+1) → X.functionField} |
|
|
| structure DivisorOpenAtlas (U : X.Opens) where |
| index : Type |
| finite : Fintype index |
| chart : index → DivisorProjectiveChart X D s |
| affine : ∀ i, IsAffineOpen (chart i).domain |
| inside : ∀ i, (chart i).domain ≤ U |
| covers : ∀ x : X, x ∈ U → ∃ i, x ∈ (chart i).domain |
| attribute [instance] DivisorOpenAtlas.finite |
| namespace DivisorOpenAtlas |
| variable {U : X.Opens} (A : DivisorOpenAtlas (D := D) (s := s) U) |
| def cover : U.toScheme.OpenCover where |
| I₀ := A.index |
| X i := (A.chart i).domain.toScheme |
| f i := X.homOfLE (A.inside i) |
| mem₀ := by |
| rw [Scheme.presieve₀_mem_precoverage_iff] |
| refine ⟨fun x => ?_,inferInstance⟩ |
| obtain ⟨i,hi⟩ := A.covers x.1 x.2 |
| exact ⟨i,⟨⟨x.1,hi⟩,Subtype.ext (by simp)⟩⟩ |
| instance : Fintype A.cover.I₀ := A.finite |
| instance (i : A.cover.I₀) : IsAffine (A.cover.X i) := A.affine i |
| def coordinate (i : A.index) (j : Fin (N+1)) : Γ(A.cover.X i,⊤) := |
| (A.chart i).domain.topIso.inv ((A.chart i).normalized j) |
| lemma cover_comp (i : A.index) : A.cover.f i ≫ U.ι = (A.chart i).domain.ι := |
| X.homOfLE_ι (A.inside i) |
| end DivisorOpenAtlas |
|
|
| theorem exists_divisorOpenAtlas [StalkwiseNormal X] [CompactSpace X] |
| (hD : IsCartierDivisor D) (hs : ∀ i, s i ≠ 0 ∧ IsDivisorSection D (s i)) |
| (U : X.Opens) (hcov : ∀ x : X, x ∈ U → ∃ i, x ∈ sectionNonvanishing D (s i)) : |
| Nonempty (DivisorOpenAtlas (D := D) (s := s) U) := by |
| classical |
| have : IsNoetherian X := ⟨⟩ |
| choose C hC hA hU using fun x : U => |
| exists_affine_divisorProjectiveChart_inside hD hs U x.1 x.2 (hcov x.1 x.2) |
| obtain ⟨S,hS⟩ := (NoetherianSpace.isCompact (U : Set X)).elim_finite_subcover |
| (fun x : U => ((C x).domain : Set X)) |
| (fun x => (C x).domain.isOpen) |
| (fun x hx => Set.mem_iUnion.mpr ⟨⟨x,hx⟩,hC ⟨x,hx⟩⟩) |
| let e := (Fintype.equivFin S).symm |
| refine ⟨⟨Fin (Fintype.card S),inferInstance,fun i => C (e i).1, |
| fun i => hA (e i).1,fun i => hU (e i).1,?_⟩⟩ |
| intro x hx |
| obtain ⟨y,hy,hxy⟩ := Set.mem_iUnion₂.mp (hS hx) |
| exact ⟨e.symm ⟨y,hy⟩,by simpa using hxy⟩ |
| theorem DivisorOpenAtlas.exists_nonzero_smooth_member |
| [StalkwiseNormal X] [CompactSpace X] |
| (sX : X ⟶ Spec (.of ℂ)) [Smooth sX] |
| {U : X.Opens} (A : DivisorOpenAtlas (D := D) (s := s) U) |
| (hs : ∀ j, s j ≠ 0) : |
| letI := schemeFieldAlgebra (.of ℂ) sX |
| ∃ (J : 𝔸(Fin (N+1);X).IdealSheafData) |
| (p : Spec (.of ℂ) ⟶ 𝔸(Fin (N+1);Spec (.of ℂ))), |
| (∀ i, J.comap (AffineSpace.map _ (A.chart i).domain.ι) = |
| Scheme.IdealSheafData.ofIdealTop (Ideal.span {universalLinearSection (A.coordinate i)})) ∧ |
| p ≫ 𝔸(Fin (N+1);Spec (.of ℂ)) ↘ Spec (.of ℂ) = 𝟙 _ ∧ |
| Smooth (((J.comap (parameterSection sX p)).comap U.ι).subschemeι ≫ (U.ι ≫ sX)) ∧ |
| parameterLinearCombination s p ≠ 0 := by |
| classical |
| let := schemeFieldAlgebra (.of ℂ) sX |
| have : IsNoetherian X := ⟨⟩ |
| have : NoetherianSpace U := U.ι.isOpenEmbedding.isInducing.noetherianSpace |
| obtain ⟨J,hJ⟩ := universal_incidence_exists (fun i => (A.chart i).domain.toScheme) |
| (fun i => (A.chart i).domain.ι) A.coordinate |
| (fun i j => divisorProjectiveChart_normalized_transition (A.chart i) (A.chart j) hs) |
| let JU := J.comap (AffineSpace.map (Fin (N+1)) U.ι) |
| have hJU (i : A.index) : JU.comap (AffineSpace.map _ (A.cover.f i)) = |
| Scheme.IdealSheafData.ofIdealTop (Ideal.span {universalLinearSection (A.coordinate i)}) := by |
| rw [← Scheme.IdealSheafData.comap_comp,← AffineSpace.map_comp,A.cover_comp] |
| exact hJ i |
| have : Smooth (JU.subschemeι ≫ 𝔸(Fin (N+1);U) ↘ U) := |
| universal_incidence_smooth_over A.cover A.coordinate |
| (fun i => ⟨(A.chart i).unit_index,by |
| change (A.chart i).domain.topIso.inv ((A.chart i).normalized (A.chart i).unit_index) = 1 |
| rw [DivisorProjectiveChart.normalized_index] |
| exact map_one _⟩) JU hJU |
| obtain ⟨T,hT,hne⟩ := exists_linear_nonvanishing_parameter_open (k := ℂ) s 0 (hs 0) |
| have : Uncountable ℂ := Cardinal.aleph0_lt_mk_iff.mp (by |
| rw [Cardinal.mk_complex]; exact Cardinal.aleph0_lt_continuum) |
| obtain ⟨p,hp,hpT,hsm⟩ := exists_very_general_incidence_member (U.ι ≫ sX) JU |
| (fun _ : Unit => T) (fun _ => hT) |
| refine ⟨J,p,hJ,hp,?_,hne p hp (hpT ())⟩ |
| have hi : (J.comap (parameterSection sX p)).comap U.ι = |
| JU.comap (parameterSection (U.ι ≫ sX) p) := by |
| rw [← Scheme.IdealSheafData.comap_comp,parameterSection_naturality, |
| Scheme.IdealSheafData.comap_comp] |
| rwa [hi] |
| 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 exists_effective_member_smooth_on_open |
| (X : ComplexProjectiveVariety) [StalkwiseNormal X.scheme] |
| [Smooth X.structureMap] (D : WeilDivisor X.scheme) |
| (hD : IsCartierDivisor D) (U : X.scheme.Opens) (hU : Nonempty U) |
| (hgen : ∀ x : X.scheme, x ∈ U → IsGeneratedAt D x) : |
| ∃ F : X.scheme.functionField, F ≠ 0 ∧ IsDivisorSection D F ∧ |
| ∀ x : X.scheme, x ∈ U → |
| letI := schemeStalkAlgebra (.of ℂ) X.structureMap x |
| ∃ a : CartierStalkEquation (D + principalWeilDivisor F) x, |
| Algebra.FormallySmooth ℂ ((X.scheme.presheaf.stalk x) ⧸ Ideal.span {a.regular}) := by |
| classical |
| let := schemeFieldAlgebra (.of ℂ) X.structureMap |
| obtain ⟨N,s,hs,hcov⟩ := generated_finite_section_cover_on_open D U hU hgen |
| obtain ⟨A⟩ := exists_divisorOpenAtlas hD hs U hcov |
| obtain ⟨J,p,hJ,hp,hsm,hF⟩ := A.exists_nonzero_smooth_member X.structureMap (fun j => (hs j).1) |
| let F := parameterLinearCombination s p |
| let I := J.comap (parameterSection X.structureMap p) |
| have : Smooth ((I.comap U.ι).subschemeι ≫ (U.ι ≫ X.structureMap)) := hsm |
| have hsec : IsDivisorSection D F := by |
| change F ∈ divisorSectionsOver (.of ℂ) X.structureMap D |
| exact (divisorSectionsOver (.of ℂ) X.structureMap D).sum_mem |
| (fun j _ => (divisorSectionsOver (.of ℂ) X.structureMap D).smul_mem |
| (parameterCoefficient p j) (hs j).2) |
| refine ⟨F,hF,hsec,?_⟩ |
| intro x hxU |
| let := schemeStalkAlgebra (.of ℂ) X.structureMap x |
| obtain ⟨i,hi⟩ := A.covers x hxU |
| let C := A.chart i |
| have : IsAffine C.domain := A.affine i |
| let a := C.member X.structureMap p |
| let b : CartierStalkEquation (D + principalWeilDivisor F) x := |
| ⟨C.domain,hi,F / s C.unit_index,div_ne_zero hF (hs _).1, |
| fun q hq => C.member_divisor_order hF (fun j => (hs j).1) q hq, |
| X.scheme.presheaf.germ C.domain x hi a,by |
| let : Nonempty C.domain := ⟨⟨x,hi⟩⟩ |
| rw [X.scheme.algebraMap_germ_eq_germToFunctionField hi] |
| exact C.member_generic X.structureMap p (fun j => (hs j).1)⟩ |
| refine ⟨b,?_⟩ |
| have hl := parameter_member_chart C.domain.ι X.structureMap p J (A.coordinate i) (hJ i) |
| change I.comap C.domain.ι = Scheme.IdealSheafData.ofIdealTop |
| (Ideal.span {linearMemberSection (C.domain.ι ≫ X.structureMap) p |
| (fun j => C.domain.topIso.inv (C.normalized j))}) at hl |
| rw [← C.member_topIso X.structureMap p] at hl |
| have : IsOpenImmersion (A.cover.f i) := |
| inferInstanceAs (IsOpenImmersion (X.scheme.homOfLE (A.inside i))) |
| have hloc := smooth_ideal_open_comap (U.ι ≫ X.structureMap) (A.cover.f i) (I.comap U.ι) |
| have hc : A.cover.f i ≫ (U.ι ≫ X.structureMap) = C.domain.ι ≫ X.structureMap := by |
| rw [← Category.assoc,A.cover_comp] |
| rfl |
| rw [← Scheme.IdealSheafData.comap_comp,A.cover_comp,hc] at hloc |
| change Smooth ((I.comap C.domain.ι).subschemeι ≫ C.domain.ι ≫ X.structureMap) at hloc |
| rw [hl] at hloc |
| exact affineOpen_hypersurface_stalk_formallySmooth X.structureMap C.domain a ⟨x,hi⟩ |
| 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 order_smooth_hypersurface_le_jacobian |
| {X : Scheme} [IsIntegral X] [IsLocallyNoetherian X] [StalkwiseNormal X] |
| (p : PrimeDivisor X) |
| {k A : Type*} [Field k] [CommRing A] [IsDomain A] [IsLocalRing A] |
| [IsNoetherianRing A] [Algebra k A] [Algebra.FormallySmooth k A] |
| [Algebra k (X.presheaf.stalk p.1)] [Algebra A (X.presheaf.stalk p.1)] |
| [IsScalarTower k A (X.presheaf.stalk p.1)] |
| {n : ℕ} (bA : Module.Basis (Fin n) A Ω[A⁄k]) |
| (bp : Module.Basis (Fin 1) (X.presheaf.stalk p.1) |
| (⋀[X.presheaf.stalk p.1]^n Ω[X.presheaf.stalk p.1⁄k])) |
| (g : A) (hg : g ≠ 0) |
| [Algebra.FormallySmooth k (A ⧸ Ideal.span {g})] |
| (hgX : algebraMap A (X.presheaf.stalk p.1) g ≠ 0) |
| (v : ⋀[A]^n Ω[A⁄k]) (c : X.presheaf.stalk p.1) |
| (hc : topDifferentialMap k A (X.presheaf.stalk p.1) n v = c • bp 0) |
| (hcf : algebraMap (X.presheaf.stalk p.1) X.functionField c ≠ 0) : |
| X.ord (algebraMap (X.presheaf.stalk p.1) X.functionField |
| (algebraMap A (X.presheaf.stalk p.1) g)) p.1 ≤ |
| X.ord (algebraMap (X.presheaf.stalk p.1) X.functionField c) p.1 + 1 := by |
| classical |
| have hcpos := (ord_nonnegative_iff_regular p _ hcf).mpr ⟨c,rfl⟩ |
| by_cases hgu : IsUnit g |
| · rw [order_stalk_unit p (hgu.map (algebraMap A (X.presheaf.stalk p.1)))] |
| omega |
| have hgm : g ∈ IsLocalRing.maximalIdeal A := by |
| rwa [IsLocalRing.mem_maximalIdeal,mem_nonunits_iff] |
| have hprim := smooth_hypersurface_differential_primitive bA g hg hgm |
| let : IsDiscreteValuationRing (X.presheaf.stalk p.1) := dvr_at_prime_divisor p |
| obtain ⟨t,ht⟩ := IsDiscreteValuationRing.exists_irreducible (X.presheaf.stalk p.1) |
| obtain ⟨e,u,he⟩ := IsDiscreteValuationRing.eq_unit_mul_pow_irreducible hgX ht |
| obtain ⟨w,hw⟩ := topDifferentialMap_divisible_of_primitive bA g hprim t (↑u) e he v |
| have hcg : c = t^(e-1) * (bp.repr w 0) := by |
| have hh := congrArg (fun z => bp.repr z 0) (hc.symm.trans hw) |
| simpa only [map_smul,Finsupp.smul_apply,smul_eq_mul,Module.Basis.repr_self, Finsupp.single_eq_same, |
| mul_one] using hh |
| rw [he,order_stalk_unit_mul_pow p t ht u e] |
| exact order_stalk_divisible_pow_lower_bound p t ht e c (bp.repr w 0) hcf hcg |
|
|
| lemma order_smooth_hypersurface_le_jacobian_chart |
| {X : Scheme} [IsIntegral X] [IsLocallyNoetherian X] [StalkwiseNormal X] |
| (p : PrimeDivisor X) |
| {k A U : Type*} [Field k] [CommRing A] [IsDomain A] [IsLocalRing A] |
| [IsNoetherianRing A] [Algebra k A] [Algebra.FormallySmooth k A] |
| [CommRing U] [Algebra k U] [Algebra U A] [IsScalarTower k U A] |
| [Algebra k (X.presheaf.stalk p.1)] [Algebra A (X.presheaf.stalk p.1)] |
| [Algebra U (X.presheaf.stalk p.1)] |
| [IsScalarTower k A (X.presheaf.stalk p.1)] |
| [IsScalarTower k U (X.presheaf.stalk p.1)] |
| [IsScalarTower U A (X.presheaf.stalk p.1)] |
| {n : ℕ} (bA : Module.Basis (Fin n) A Ω[A⁄k]) |
| (bp : Module.Basis (Fin 1) (X.presheaf.stalk p.1) |
| (⋀[X.presheaf.stalk p.1]^n Ω[X.presheaf.stalk p.1⁄k])) |
| (g : A) (hg : g ≠ 0) |
| [Algebra.FormallySmooth k (A ⧸ Ideal.span {g})] |
| (hgX : algebraMap A (X.presheaf.stalk p.1) g ≠ 0) |
| (v : ⋀[U]^n Ω[U⁄k]) (c : X.presheaf.stalk p.1) |
| (hc : topDifferentialMap k U (X.presheaf.stalk p.1) n v = c • bp 0) |
| (hcf : algebraMap (X.presheaf.stalk p.1) X.functionField c ≠ 0) : |
| X.ord (algebraMap (X.presheaf.stalk p.1) X.functionField |
| (algebraMap A (X.presheaf.stalk p.1) g)) p.1 ≤ |
| X.ord (algebraMap (X.presheaf.stalk p.1) X.functionField c) p.1 + 1 := by |
| have hh := LinearMap.congr_fun (topDifferentialMap_comp k U A (X.presheaf.stalk p.1) n) v |
| simp only [LinearMap.comp_apply,LinearMap.restrictScalars_apply] at hh |
| exact order_smooth_hypersurface_le_jacobian p bA bp g hg hgX |
| (topDifferentialMap k U A n v) c (hh.trans hc) hcf |
|
|
| lemma cartier_order_le_jacobian_of_chart |
| {X Y : Scheme} [IsIntegral X] [IsIntegral Y] |
| [IsLocallyNoetherian X] [IsLocallyNoetherian Y] |
| [StalkwiseNormal X] [StalkwiseNormal Y] |
| (f : X ⟶ Y) [IsDominant f] (D : WeilDivisor Y) |
| (T : WeilDivisor X) (hT : IsCartierPullback f D T) (p : PrimeDivisor X) |
| {k U : Type*} [Field k] [CommRing U] [Algebra k U] |
| [Algebra k (Y.presheaf.stalk (f p.1))] |
| [Algebra.FormallySmooth k (Y.presheaf.stalk (f p.1))] |
| [Algebra k (X.presheaf.stalk p.1)] |
| [Algebra (Y.presheaf.stalk (f p.1)) (X.presheaf.stalk p.1)] |
| [Algebra U (Y.presheaf.stalk (f p.1))] [Algebra U (X.presheaf.stalk p.1)] |
| [IsScalarTower k U (Y.presheaf.stalk (f p.1))] |
| [IsScalarTower k U (X.presheaf.stalk p.1)] |
| [IsScalarTower k (Y.presheaf.stalk (f p.1)) (X.presheaf.stalk p.1)] |
| [IsScalarTower U (Y.presheaf.stalk (f p.1)) (X.presheaf.stalk p.1)] |
| (hmap : algebraMap (Y.presheaf.stalk (f p.1)) (X.presheaf.stalk p.1) = |
| (f.stalkMap p.1).hom) |
| {n : ℕ} (bY : Module.Basis (Fin n) (Y.presheaf.stalk (f p.1)) |
| Ω[Y.presheaf.stalk (f p.1)⁄k]) |
| (bp : Module.Basis (Fin 1) (X.presheaf.stalk p.1) |
| (⋀[X.presheaf.stalk p.1]^n Ω[X.presheaf.stalk p.1⁄k])) |
| (g : CartierStalkEquation D (f p.1)) |
| [Algebra.FormallySmooth k ((Y.presheaf.stalk (f p.1)) ⧸ Ideal.span {g.regular})] |
| (v : ⋀[U]^n Ω[U⁄k]) (c : X.presheaf.stalk p.1) |
| (hc : topDifferentialMap k U (X.presheaf.stalk p.1) n v = c • bp 0) |
| (hcf : algebraMap (X.presheaf.stalk p.1) X.functionField c ≠ 0) : |
| T p ≤ X.ord (algebraMap (X.presheaf.stalk p.1) X.functionField c) p.1 + 1 := by |
| have hgmap : algebraMap (X.presheaf.stalk p.1) X.functionField |
| (algebraMap (Y.presheaf.stalk (f p.1)) (X.presheaf.stalk p.1) g.regular) = |
| dominantFunctionFieldMap f g.function := by |
| rw [hmap,← g.regular_eq,dominantFunctionFieldMap_algebraMap] |
| have hgnz : g.regular ≠ 0 := by |
| intro hz |
| exact g.nonzero (by rw [← g.regular_eq,hz,map_zero]) |
| have hgXnz : algebraMap (Y.presheaf.stalk (f p.1)) (X.presheaf.stalk p.1) g.regular ≠ 0 := by |
| intro hz |
| have hn := (map_ne_zero (dominantFunctionFieldMap f)).mpr g.nonzero |
| exact hn (by rw [← hgmap,hz,map_zero]) |
| have hb := order_smooth_hypersurface_le_jacobian_chart p bY bp g.regular |
| hgnz hgXnz v c hc hcf |
| have hTord := hT.order_eq_of_equation g.nonzero g.equation p g.mem_openSet |
| exact (hTord.trans (congrArg (fun z => X.ord z p.1) hgmap.symm)).le.trans hb |
|
|
| lemma topDifferentialMap_scalar_chart |
| {k A B C F : Type*} [CommRing k] [CommRing A] [CommRing B] [CommRing C] [CommRing F] |
| [Algebra k A] [Algebra k B] [Algebra k C] [Algebra k F] |
| [Algebra A B] [Algebra A C] [Algebra A F] [Algebra B F] [Algebra C F] |
| [IsScalarTower k A B] [IsScalarTower k A C] [IsScalarTower k A F] |
| [IsScalarTower k B F] [IsScalarTower k C F] |
| [IsScalarTower A B F] [IsScalarTower A C F] |
| (n : ℕ) (u : ⋀[A]^n Ω[A⁄k]) (v : ⋀[C]^n Ω[C⁄k]) |
| (ω : ⋀[B]^n Ω[B⁄k]) (a : B) (c : C) |
| (hω : ω = a • topDifferentialMap k A B n u) |
| (hc : topDifferentialMap k A C n u = c • v) : |
| topDifferentialMap k B F n ω = |
| (algebraMap B F a * algebraMap C F c) • topDifferentialMap k C F n v := by |
| rw [hω,map_smul,← IsScalarTower.algebraMap_smul F a] |
| have h₁ := LinearMap.congr_fun (topDifferentialMap_comp k A B F n) u |
| have h₂ := LinearMap.congr_fun (topDifferentialMap_comp k A C F n) u |
| simp only [LinearMap.comp_apply,LinearMap.restrictScalars_apply] at h₁ h₂ |
| rw [h₁,← h₂,hc,map_smul,← IsScalarTower.algebraMap_smul F c,← mul_smul] |
|
|
| theorem smooth_boundary_discrepancy_bound_at |
| (X Y : ComplexProjectiveVariety) (n : ℕ) |
| (hX : IsSmoothNfold X n) (hY : IsSmoothNfold Y n) |
| [StalkwiseNormal Y.scheme] |
| (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) |
| (D : WeilDivisor Y.scheme) |
| (T : WeilDivisor X.scheme) (hT : IsCartierPullback f D T) |
| (p : PrimeDivisor X.scheme) |
| (hg : letI := schemeStalkAlgebra (.of ℂ) Y.structureMap (f p.1) |
| ∃ g : CartierStalkEquation D (f p.1), |
| Algebra.FormallySmooth ℂ ((Y.scheme.presheaf.stalk (f p.1)) ⧸ Ideal.span {g.regular})) : |
| T p ≤ (DX-P) p + 1 := 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) |
| change T p ≤ DX p - P p + 1 |
| 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.order_eq_of_equation 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 |
| exact topDifferentialMap_scalar_chart n (bU 0) (bp 0) ω a c heq hc |
| 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 |
| obtain ⟨g, hgSmooth⟩ := hg |
| have hbound : T p ≤ X.scheme.ord cf p.1 + 1 := by |
| let : Algebra.FormallySmooth ℂ (Y.scheme.presheaf.stalk (f p.1)) := |
| formallySmooth_smooth_stalk Y.structureMap n (f p.1) |
| let : Algebra.FormallySmooth ℂ |
| ((Y.scheme.presheaf.stalk (f p.1)) ⧸ Ideal.span {g.regular}) := hgSmooth |
| obtain ⟨bY⟩ := nonempty_smooth_stalk_differential_basis Y.structureMap n (f p.1) |
| let : Algebra (Y.scheme.presheaf.stalk (f p.1)) (X.scheme.presheaf.stalk p.1) := |
| (f.stalkMap p.1).hom.toAlgebra |
| let : IsScalarTower ℂ (Y.scheme.presheaf.stalk (f p.1)) (X.scheme.presheaf.stalk p.1) := by |
| apply IsScalarTower.of_algebraMap_eq |
| intro z |
| exact (dominant_stalk_scalar (.of ℂ) X.structureMap Y.structureMap f hf p.1 z).symm |
| let : IsScalarTower Γ(Y.scheme,U) (Y.scheme.presheaf.stalk (f p.1)) |
| (X.scheme.presheaf.stalk p.1) := by |
| apply IsScalarTower.of_algebraMap_eq |
| intro z |
| rfl |
| exact cartier_order_le_jacobian_of_chart f D T hT p rfl bY bp g (bU 0) c hc hcf |
| rw [hDXp, hDXord, X.scheme.ord_mul ((map_ne_zero _).mpr ha) hcf, hPa] |
| omega |
| 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 exists_effective_locally_klt_member |
| {n : ℕ} (Y : CanonicalModel n) (hY : IsSmoothNfold Y.toComplexProjectiveVariety n) |
| (D : WeilDivisor Y.scheme) (hD : IsCartierDivisor D) |
| (U : Y.scheme.Opens) (hU : Nonempty U) |
| (hgen : ∀ x : Y.scheme, x ∈ U → IsGeneratedAt D x) |
| (ε : ℚ) (hε : 0 ≤ ε) (hε1 : ε < 1) : |
| ∃ F : Y.scheme.functionField, F ≠ 0 ∧ IsDivisorSection D F ∧ |
| let Δ := ε • rationalWeilDivisor (D + principalWeilDivisor F) |
| 0 ≤ Δ ∧ IsQCartierDivisor (rationalWeilDivisor Y.canonical + Δ) ∧ |
| ∀ W : ComplexProjectiveVariety, IsSmoothNfold W n → |
| ∀ f : W.scheme ⟶ Y.scheme, ∀ (_ : IsDominant f), |
| IsProper f → IsBirationalMorphism f → |
| ∀ hf : f ≫ Y.structureMap = W.structureMap, |
| ∀ KW : WeilDivisor W.scheme, |
| IsCanonicalDivisorOf (.of ℂ) W.structureMap n |
| (rationalTopFormPullback (.of ℂ) W.structureMap Y.structureMap f hf n Y.form) KW → |
| ∀ P : QWeilDivisor W.scheme, |
| IsQCartierPullback f (rationalWeilDivisor Y.canonical + Δ) P → |
| ∀ p : PrimeDivisor W.scheme, f p.1 ∈ U → |
| -1 < (rationalWeilDivisor KW - P) p := by |
| let : SmoothOfRelativeDimension n Y.structureMap := hY |
| let : Smooth Y.structureMap := SmoothOfRelativeDimension.smooth n Y.structureMap |
| obtain ⟨F,hF,hsec,hsm⟩ := exists_effective_member_smooth_on_open |
| Y.toComplexProjectiveVariety D hD U hU hgen |
| let E := D + principalWeilDivisor F |
| have hE : IsCartierDivisor E := isCartierDivisor_add hD (isCartierDivisor_principal hF) |
| have heff : 0 ≤ E := by |
| intro p |
| have hs := hsec.resolve_left hF p |
| change 0 ≤ D p + Y.scheme.ord F p.1 |
| omega |
| have hK := canonicalModel_isCartier Y hY |
| let M : CartierMultiple (rationalWeilDivisor Y.canonical) := ⟨1,by decide,⟨_,hK⟩,by simp⟩ |
| let N : CartierMultiple (rationalWeilDivisor E) := ⟨1,by decide,⟨_,hE⟩,by simp⟩ |
| let R := M.add (N.smul ε) |
| refine ⟨F,hF,hsec,?_,⟨R.denominator,R.positive,R.divisor.1,R.divisor.2,R.equation⟩,?_⟩ |
| · intro p |
| change 0 ≤ ε * (E p : ℚ) |
| exact mul_nonneg hε (by exact_mod_cast heff p) |
| intro W hW f hdom _hproper _hbir hf KW hKW Q hQ p hpU |
| let : IsDominant f := hdom |
| let : StalkwiseNormal W.scheme := smoothNormal W hW |
| obtain ⟨P,hP⟩ := exists_cartierPullback f Y.canonical hK |
| obtain ⟨T,hT⟩ := exists_cartierPullback f E hE |
| have he := hQ.unique ((hP.rational hK).add ((hT.rational hE).smul ε)) |
| rw [he] |
| have ha := smooth_relative_canonical_effective W Y.toComplexProjectiveVariety n hW hY |
| f hf Y.form KW Y.canonical hKW Y.canonical_of_form P hP p |
| have hb := smooth_boundary_discrepancy_bound_at W Y.toComplexProjectiveVariety n hW hY |
| f hf Y.form KW Y.canonical hKW Y.canonical_of_form P hP E T hT p (hsm (f p.1) hpU) |
| have haQ : (0 : ℚ) ≤ (KW p : ℚ) - (P p : ℚ) := by exact_mod_cast ha |
| have hbQ : (T p : ℚ) ≤ (KW p : ℚ) - (P p : ℚ) + 1 := by exact_mod_cast hb |
| have hm := mul_le_mul_of_nonneg_left hbQ hε |
| have hs : 0 < (1-ε)*((KW p : ℚ)-(P p : ℚ)+1) := |
| mul_pos (sub_pos.mpr hε1) (by linarith) |
| change -1 < (KW p : ℚ) - ((P p : ℚ) + ε * (T p : ℚ)) |
| nlinarith |
| end NumericalDimensionOne |
|
|
| end OAI |
|
|
