Download data/lean/OAI/AlgebraicGeometry/NumericalDimension/NormalCrossings.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 26.9 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/NumericalDimension/NormalCrossings.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/AlgebraicGeometry/NumericalDimension/NormalCrossings.lean
-
curl -L -o NormalCrossings.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/AlgebraicGeometry/NumericalDimension/NormalCrossings.lean
26.9 kB
| import Mathlib | |
| import OAI.AlgebraicGeometry.NumericalDimension.DifferentialDivisibility | |
| import OAI.AlgebraicGeometry.NumericalDimension.KltMembers | |
| namespace OAI | |
| /-! Normal Crossings. -/ | |
| 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 | |
| open AlgebraicGeometry CategoryTheory TopologicalSpace Filter | |
| open Opposite TopCat | |
| open AlgebraicGeometry CategoryTheory TopCat Opposite TopologicalSpace | |
| open CategoryTheory.Limits | |
| namespace NumericalDimensionOne | |
| noncomputable section | |
| lemma topDifferentialMap_coefficient_pullback | |
| (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 : β) (Ο : β[B]^n Ξ©[Bβk]) (u : β[A]^n Ξ©[Aβk]) | |
| (v : β[C]^n Ξ©[Cβk]) (a : B) (c : C) | |
| (hΟ : Ο = a β’ topDifferentialMap k A B n u) | |
| (hv : 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β, hv, map_smul, β IsScalarTower.algebraMap_smul F c, β mul_smul] | |
| lemma canonical_germ_generator | |
| (Y : Scheme) [IsIntegral Y] [IsLocallyNoetherian Y] | |
| (sY : Y βΆ Spec (.of β)) (n : β) [SmoothOfRelativeDimension n sY] | |
| (Ο : rationalTopForms (.of β) sY n) (D : WeilDivisor Y) | |
| (hD : IsCanonicalDivisorOf (.of β) sY n Ο D) (y : Y) : | |
| letI := schemeStalkAlgebra (.of β) sY y | |
| letI := schemeFieldAlgebra (.of β) sY | |
| letI := stalk_field_scalar_tower (.of β) sY y | |
| β (U : Y.Opens) (_ : y β U) (a : Y.functionField) | |
| (v : β[Y.presheaf.stalk y]^n Ξ©[(Y.presheaf.stalk y)ββ]), | |
| a β 0 β§ Ο = a β’ topDifferentialMap β (Y.presheaf.stalk y) Y.functionField n v β§ | |
| β p : PrimeDivisor Y, p.1 β U β D p = Y.ord a p.1 := by | |
| classical | |
| let := schemeStalkAlgebra (.of β) sY y | |
| let := schemeFieldAlgebra (.of β) sY | |
| let := stalk_field_scalar_tower (.of β) sY y | |
| obtain β¨U, hU, hyU, hsβ© := exists_standard_smooth_chart sY n y | |
| let : Nonempty U := β¨β¨y,hyUβ©β© | |
| let := schemeOpenAlgebra sY U | |
| let : Algebra.IsStandardSmoothOfRelativeDimension n β Ξ(Y,U) := hs | |
| let : Algebra.IsStandardSmooth β Ξ(Y,U) := | |
| Algebra.IsStandardSmoothOfRelativeDimension.isStandardSmooth n | |
| let := open_field_scalar_tower sY U | |
| let := functionField_isFractionRing_of_isAffineOpen Y U hU | |
| let : Algebra.FormallyEtale Ξ(Y,U) Y.functionField := | |
| Algebra.FormallyEtale.of_isLocalization (nonZeroDivisors Ξ(Y,U)) | |
| obtain β¨bUβ© := nonempty_topDifferential_basis β Ξ(Y,U) n | |
| let bF := (topDifferential_isBaseChange β Ξ(Y,U) Y.functionField n).basis bU | |
| let a := bF.repr Ο 0 | |
| have heq : Ο = a β’ topDifferentialMap β Ξ(Y,U) Y.functionField n (bU 0) := by | |
| simpa only [bF, IsBaseChange.basis_apply] using basis_singleton_repr bF Ο | |
| have ha : a β 0 := by | |
| intro h | |
| exact hD.1 (by simpa [h] using heq) | |
| let u : U := β¨y,hyUβ© | |
| let := TopCat.Presheaf.algebra_section_stalk Y.presheaf u | |
| let := open_stalk_scalar_tower sY U u | |
| let := functionField_isScalarTower Y U u | |
| refine β¨U,hyU,a,topDifferentialMap β Ξ(Y,U) (Y.presheaf.stalk y) n (bU 0),ha,?_, | |
| canonical_chart_equation sY n hD U hU hs bU a ha heqβ© | |
| exact heq.trans (congrArg (fun v => a β’ v) | |
| (LinearMap.congr_fun (topDifferentialMap_comp β Ξ(Y,U) | |
| (Y.presheaf.stalk y) Y.functionField n) (bU 0)).symm) | |
| lemma canonical_ramification_coefficient | |
| (X Y : Scheme) [IsIntegral X] [IsIntegral Y] | |
| [IsLocallyNoetherian X] [IsLocallyNoetherian Y] | |
| [StalkwiseNormal X] [StalkwiseNormal Y] | |
| (sX : X βΆ Spec (.of β)) (sY : Y βΆ Spec (.of β)) (n : β) | |
| [SmoothOfRelativeDimension n sX] [SmoothOfRelativeDimension n sY] | |
| (f : X βΆ Y) [IsDominant f] (hf : f β« sY = sX) | |
| (Ο : rationalTopForms (.of β) sY n) | |
| (DX : WeilDivisor X) (DY : WeilDivisor Y) | |
| (hDX : IsCanonicalDivisorOf (.of β) sX n | |
| (rationalTopFormPullback (.of β) sX sY f hf n Ο) DX) | |
| (hDY : IsCanonicalDivisorOf (.of β) sY n Ο DY) | |
| (P : WeilDivisor X) (hP : IsCartierPullback f DY P) (p : PrimeDivisor X) : | |
| letI := schemeStalkAlgebra (.of β) sY (f p.1) | |
| letI := schemeStalkAlgebra (.of β) sX p.1 | |
| letI : Algebra (Y.presheaf.stalk (f p.1)) (X.presheaf.stalk p.1) := | |
| (f.stalkMap p.1).hom.toAlgebra | |
| letI : IsScalarTower β (Y.presheaf.stalk (f p.1)) (X.presheaf.stalk p.1) := | |
| IsScalarTower.of_algebraMap_eq (fun z => (dominant_stalk_scalar (.of β) sX sY f hf p.1 z).symm) | |
| β (v : β[Y.presheaf.stalk (f p.1)]^n Ξ©[(Y.presheaf.stalk (f p.1))ββ]) | |
| (b : Module.Basis (Fin 1) (X.presheaf.stalk p.1) | |
| (β[X.presheaf.stalk p.1]^n Ξ©[(X.presheaf.stalk p.1)ββ])) | |
| (c : X.presheaf.stalk p.1), | |
| topDifferentialMap β (Y.presheaf.stalk (f p.1)) (X.presheaf.stalk p.1) n v = c β’ b 0 β§ | |
| algebraMap (X.presheaf.stalk p.1) X.functionField c β 0 β§ | |
| DX p - P p = X.ord (algebraMap (X.presheaf.stalk p.1) X.functionField c) p.1 | |
| := by | |
| classical | |
| let := schemeStalkAlgebra (.of β) sY (f p.1) | |
| let := schemeFieldAlgebra (.of β) sX | |
| let := schemeFieldAlgebra (.of β) sY | |
| let := stalk_field_scalar_tower (.of β) sY (f p.1) | |
| let : Algebra Y.functionField X.functionField := | |
| (dominantFunctionFieldMap f).toAlgebra | |
| let : IsScalarTower β Y.functionField X.functionField := | |
| IsScalarTower.of_algebraMap_eq (fun a => | |
| (dominantFunctionFieldMap_scalar (.of β) sX sY f hf a).symm) | |
| obtain β¨U, hpU, a, v, ha, heq, hDaβ© := canonical_germ_generator Y sY n Ο DY hDY (f p.1) | |
| have hPa := hP.order_eq_of_equation ha hDa p hpU | |
| let := schemeStalkAlgebra (.of β) sX p.1 | |
| let := stalk_field_scalar_tower (.of β) sX p.1 | |
| let : Algebra (Y.presheaf.stalk (f p.1)) (X.presheaf.stalk p.1) := | |
| (f.stalkMap p.1).hom.toAlgebra | |
| let : IsScalarTower β (Y.presheaf.stalk (f p.1)) (X.presheaf.stalk p.1) := | |
| IsScalarTower.of_algebraMap_eq (fun z => (dominant_stalk_scalar (.of β) sX sY f hf p.1 z).symm) | |
| let : Algebra (Y.presheaf.stalk (f p.1)) X.functionField := | |
| ((dominantFunctionFieldMap f).comp (algebraMap (Y.presheaf.stalk (f p.1)) Y.functionField)).toAlgebra | |
| let : IsScalarTower (Y.presheaf.stalk (f p.1)) Y.functionField X.functionField := | |
| IsScalarTower.of_algebraMap_eq (fun _ => rfl) | |
| let : IsScalarTower β (Y.presheaf.stalk (f p.1)) X.functionField := by | |
| apply IsScalarTower.of_algebraMap_eq | |
| intro z | |
| change algebraMap β X.functionField z = dominantFunctionFieldMap f | |
| (algebraMap (Y.presheaf.stalk (f p.1)) Y.functionField | |
| (algebraMap β (Y.presheaf.stalk (f p.1)) z)) | |
| rw [β IsScalarTower.algebraMap_apply] | |
| exact (dominantFunctionFieldMap_scalar (.of β) sX sY f hf z).symm | |
| let : IsScalarTower (Y.presheaf.stalk (f p.1)) (X.presheaf.stalk p.1) X.functionField := | |
| IsScalarTower.of_algebraMap_eq (fun z => dominantFunctionFieldMap_algebraMap f p.1 z) | |
| obtain β¨bpβ© := nonempty_smooth_canonical_stalk_basis sX n p.1 | |
| let c := bp.repr (topDifferentialMap β (Y.presheaf.stalk (f p.1)) | |
| (X.presheaf.stalk p.1) n v) 0 | |
| have hc : topDifferentialMap β (Y.presheaf.stalk (f p.1)) (X.presheaf.stalk p.1) n v = | |
| c β’ bp 0 := basis_singleton_repr bp _ | |
| let cf := algebraMap (X.presheaf.stalk p.1) X.functionField c | |
| have hpull : rationalTopFormPullback (.of β) sX sY f hf n Ο = | |
| (dominantFunctionFieldMap f a * cf) β’ | |
| topDifferentialMap β (X.presheaf.stalk p.1) X.functionField n (bp 0) := by | |
| change topDifferentialMap β Y.functionField X.functionField n Ο = _ | |
| exact topDifferentialMap_coefficient_pullback β (Y.presheaf.stalk (f p.1)) Y.functionField | |
| (X.presheaf.stalk p.1) X.functionField n Ο v (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 sX n p _ cp bp a' | |
| (dominantFunctionFieldMap f a * cf) hDX.1 ha' hprod heq' hpull | |
| refine β¨v, bp, c, hc, hcf, ?_β© | |
| change DX p - P p = X.ord cf p.1 | |
| rw [hDXp, hDXord, X.ord_mul ((map_ne_zero _).mpr ha) hcf, hPa] | |
| omega | |
| theorem independent_boundary_discrepancy_bound_scheme | |
| (X Y : Scheme) [IsIntegral X] [IsIntegral Y] | |
| [IsLocallyNoetherian X] [IsLocallyNoetherian Y] | |
| [StalkwiseNormal X] [StalkwiseNormal Y] | |
| (sX : X βΆ Spec (.of β)) (sY : Y βΆ Spec (.of β)) (n : β) | |
| [SmoothOfRelativeDimension n sX] [SmoothOfRelativeDimension n sY] | |
| (f : X βΆ Y) [IsDominant f] | |
| (hf : f β« sY = sX) | |
| (Ο : rationalTopForms (.of β) sY n) | |
| (DX : WeilDivisor X) (DY : WeilDivisor Y) | |
| (hDX : IsCanonicalDivisorOf (.of β) sX n | |
| (rationalTopFormPullback (.of β) sX sY f hf n Ο) DX) | |
| (hDY : IsCanonicalDivisorOf (.of β) sY n Ο DY) | |
| (P : WeilDivisor X) (hP : IsCartierPullback f DY P) | |
| {ΞΉ : Type*} [Fintype ΞΉ] | |
| (D : ΞΉ β WeilDivisor Y) (T : ΞΉ β WeilDivisor X) | |
| (hT : β i, IsCartierPullback f (D i) (T i)) (p : PrimeDivisor X) : | |
| letI := schemeStalkAlgebra (.of β) sY (f p.1) | |
| β (g : β i, CartierStalkEquation (D i) (f p.1)) | |
| (b : Module.Basis (Fin n) (Y.presheaf.stalk (f p.1)) | |
| Ξ©[(Y.presheaf.stalk (f p.1))ββ]) (Ο : ΞΉ βͺ Fin n), | |
| (β i, KaehlerDifferential.D β (Y.presheaf.stalk (f p.1)) | |
| (g i).regular = b (Ο i)) β | |
| (β i, T i p) β€ (DX - P) p + 1 := by | |
| classical | |
| let := schemeStalkAlgebra (.of β) sY (f p.1) | |
| intro g bY Ο hg | |
| let := schemeStalkAlgebra (.of β) sX p.1 | |
| let : Algebra (Y.presheaf.stalk (f p.1)) (X.presheaf.stalk p.1) := | |
| (f.stalkMap p.1).hom.toAlgebra | |
| let : IsScalarTower β (Y.presheaf.stalk (f p.1)) (X.presheaf.stalk p.1) := | |
| IsScalarTower.of_algebraMap_eq (fun z => (dominant_stalk_scalar (.of β) sX sY f hf p.1 z).symm) | |
| obtain β¨v, bp, c, hc, hcf, hDiffβ© := canonical_ramification_coefficient | |
| X Y sX sY n f hf Ο DX DY hDX hDY P hP p | |
| let cf := algebraMap (X.presheaf.stalk p.1) X.functionField c | |
| let gX (i : ΞΉ) := f.stalkMap p.1 (g i).regular | |
| have hgX (i : ΞΉ) : | |
| algebraMap (X.presheaf.stalk p.1) X.functionField (gX i) = | |
| dominantFunctionFieldMap f (g i).function := by | |
| rw [β (g i).regular_eq, dominantFunctionFieldMap_algebraMap] | |
| have hTord (i : ΞΉ) := (hT i).order_eq_of_equation (g i).nonzero | |
| (g i).equation p (g i).mem_openSet | |
| have hgXnz (i : ΞΉ) : gX i β 0 := by | |
| intro hz | |
| have hgn : dominantFunctionFieldMap f (g i).function β 0 := (map_ne_zero _).mpr (g i).nonzero | |
| apply hgn | |
| rw [β hgX i, hz, map_zero] | |
| let : IsDiscreteValuationRing (X.presheaf.stalk p.1) := dvr_at_prime_divisor p | |
| obtain β¨t, htβ© := IsDiscreteValuationRing.exists_irreducible (X.presheaf.stalk p.1) | |
| have hdecomp (i : ΞΉ) := IsDiscreteValuationRing.eq_unit_mul_pow_irreducible (hgXnz i) ht | |
| choose e uu he using hdecomp | |
| obtain β¨w, hwβ© := topDifferentialMap_divisible_of_independent_equations bY Ο | |
| (fun i => (g i).regular) t (fun i => β(uu i)) e hg he | |
| v | |
| have hcg : c = t ^ ((β i, e i) - 1) * (bp.repr w 0) := by | |
| have hz := congrArg (fun z => bp.repr z 0) (hc.symm.trans hw) | |
| simpa only [map_smul, Finsupp.smul_apply, Module.Basis.repr_self, Finsupp.single_eq_same, | |
| smul_eq_mul, mul_one] using hz | |
| have hTe (i : ΞΉ) : T i p = (e i : β€) := by | |
| rw [hTord i, β hgX i, he i] | |
| exact order_stalk_unit_mul_pow p t ht (uu i) (e i) | |
| have hsum_T : (β i, T i p) = ((β i, e i) : β) := by | |
| simp only [hTe, Nat.cast_sum] | |
| have hbound : (β i, T i p) β€ X.ord cf p.1 + 1 := by | |
| rw [hsum_T] | |
| exact order_stalk_divisible_pow_lower_bound p t ht (β i, e i) c | |
| (bp.repr w 0) hcf hcg | |
| change (β i, T i p) β€ DX p - P p + 1 | |
| change (β i, T i p) β€ X.ord cf p.1 + 1 at hbound | |
| change DX p - P p = X.ord cf p.1 at hDiff | |
| rwa [hDiff] | |
| theorem independent_boundary_discrepancy_bound | |
| (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) | |
| {ΞΉ : Type*} [Fintype ΞΉ] | |
| (D : ΞΉ β WeilDivisor Y.scheme) (T : ΞΉ β WeilDivisor X.scheme) | |
| (hT : β i, IsCartierPullback f (D i) (T i)) (p : PrimeDivisor X.scheme) : | |
| letI := schemeStalkAlgebra (.of β) Y.structureMap (f p.1) | |
| β (g : β i, CartierStalkEquation (D i) (f p.1)) | |
| (b : Module.Basis (Fin n) (Y.scheme.presheaf.stalk (f p.1)) | |
| Ξ©[(Y.scheme.presheaf.stalk (f p.1))ββ]) (Ο : ΞΉ βͺ Fin n), | |
| (β i, KaehlerDifferential.D β (Y.scheme.presheaf.stalk (f p.1)) | |
| (g i).regular = b (Ο i)) β | |
| (β i, T i p) β€ (DX - P) p + 1 := by | |
| let : SmoothOfRelativeDimension n X.structureMap := hX | |
| let : SmoothOfRelativeDimension n Y.structureMap := hY | |
| let : StalkwiseNormal X.scheme := smoothNormal X hX | |
| exact independent_boundary_discrepancy_bound_scheme X.scheme Y.scheme | |
| X.structureMap Y.structureMap n f hf Ο DX DY hDX hDY P hP D T hT p | |
| def IsSimpleNormalCrossingsDivisorFamily | |
| (Y : ComplexProjectiveVariety) (n : β) [StalkwiseNormal Y.scheme] | |
| {ΞΉ : Type*} [Fintype ΞΉ] (D : ΞΉ β WeilDivisor Y.scheme) : Prop := | |
| (β i, IsCartierDivisor (D i) β§ 0 β€ D i) β§ | |
| β x : Y.scheme, | |
| letI := schemeStalkAlgebra (.of β) Y.structureMap x | |
| β (g : β i, CartierStalkEquation (D i) x) | |
| (b : Module.Basis (Fin n) (Y.scheme.presheaf.stalk x) Ξ©[(Y.scheme.presheaf.stalk x)ββ]) | |
| (S : Finset ΞΉ) (Ο : S βͺ Fin n), | |
| (β i : S, KaehlerDifferential.D β (Y.scheme.presheaf.stalk x) (g i.1).regular = b (Ο i)) β§ | |
| (β i β S, IsUnit (g i).regular) | |
| theorem snc_boundary_discrepancy_bound | |
| (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) | |
| {ΞΉ : Type*} [Fintype ΞΉ] (D : ΞΉ β WeilDivisor Y.scheme) | |
| (hD : IsSimpleNormalCrossingsDivisorFamily Y n D) | |
| (T : ΞΉ β WeilDivisor X.scheme) (hT : β i, IsCartierPullback f (D i) (T i)) : | |
| β p : PrimeDivisor X.scheme, (β i, T i p) β€ (DX - P) p + 1 := by | |
| classical | |
| intro p | |
| let := schemeStalkAlgebra (.of β) Y.structureMap (f p.1) | |
| obtain β¨g, b, S, Ο, hcoord, hunitβ© := hD.2 (f p.1) | |
| have hactive := independent_boundary_discrepancy_bound X Y n hX hY f hf Ο DX DY | |
| hDX hDY P hP (fun i : S => D i.1) (fun i : S => T i.1) | |
| (fun i => hT i.1) p (fun i => g i.1) b Ο hcoord | |
| have hzero (i : ΞΉ) (hi : i β S) : T i p = 0 := by | |
| have hTord := (hT i).order_eq_of_equation (g i).nonzero (g i).equation p (g i).mem_openSet | |
| rw [hTord, β (g i).regular_eq, dominantFunctionFieldMap_algebraMap] | |
| exact order_stalk_unit p ((hunit i hi).map (f.stalkMap p.1).hom) | |
| have hsum : (β i : S, T i.1 p) = β i, T i p := by | |
| rw [Finset.sum_coe_sort S (fun i => T i p)] | |
| exact Finset.sum_subset (Finset.subset_univ _) (fun i _ hi => hzero i hi) | |
| rwa [hsum] at hactive | |
| lemma IsQCartierPullback.sum {X Y : Scheme} [IsIntegral X] [IsIntegral Y] | |
| [IsLocallyNoetherian X] [IsLocallyNoetherian Y] | |
| {f : X βΆ Y} [IsDominant f] {ΞΉ : Type*} (S : Finset ΞΉ) | |
| {D : ΞΉ β QWeilDivisor Y} {P : ΞΉ β QWeilDivisor X} | |
| (hP : β i β S, IsQCartierPullback f (D i) (P i)) : | |
| IsQCartierPullback f (β i β S, D i) (β i β S, P i) := by | |
| classical | |
| induction S using Finset.induction_on with | |
| | empty => | |
| simpa [rationalWeilDivisor] using (isCartierPullback_zero f).rational (cartierDivisors (X := Y)).zero_mem | |
| | @insert i S hi ih => | |
| rw [Finset.sum_insert hi, Finset.sum_insert hi] | |
| exact (hP i (Finset.mem_insert_self _ _)).add | |
| (ih (fun j hj => hP j (Finset.mem_insert_of_mem hj))) | |
| theorem snc_boundary_isKlt | |
| {n : β} (Y : CanonicalModel n) (hY : IsSmoothNfold Y.toComplexProjectiveVariety n) | |
| {ΞΉ : Type*} [Fintype ΞΉ] (D : ΞΉ β WeilDivisor Y.scheme) | |
| (hD : IsSimpleNormalCrossingsDivisorFamily Y.toComplexProjectiveVariety n D) | |
| (c : ΞΉ β β) (hc : β i, 0 β€ c i) (hc1 : β i, c i < 1) : | |
| IsKltBoundary Y (β i, c i β’ rationalWeilDivisor (D i)) := by | |
| classical | |
| have hK := canonicalModel_isCartier Y hY | |
| have hid : IsQCartierPullback (π Y.scheme) | |
| (β i, c i β’ rationalWeilDivisor (D i)) | |
| (β i, c i β’ rationalWeilDivisor (D i)) := | |
| IsQCartierPullback.sum Finset.univ (fun i _ => | |
| ((hD.1 i).1.pullback_id.rational (hD.1 i).1).smul (c i)) | |
| have hKpull := hK.pullback_id.rational hK | |
| refine β¨?_, (hKpull.add hid).isQCartier, ?_β© | |
| Β· intro p | |
| rw [Finsupp.finsetSum_apply] | |
| exact Finset.sum_nonneg (fun i _ => mul_nonneg (hc i) (by | |
| change 0 β€ (D i p : β) | |
| exact_mod_cast (hD.1 i).2 p)) | |
| intro W hW f hdom _hproper _hbir hf KW hKW Q hQ p | |
| let : IsDominant f := hdom | |
| let : StalkwiseNormal W.scheme := smoothNormal W hW | |
| obtain β¨P, hPβ© := exists_cartierPullback f Y.canonical hK | |
| have hex (i : ΞΉ) := exists_cartierPullback f (D i) (hD.1 i).1 | |
| choose T hT using hex | |
| have hsumPull : IsQCartierPullback f | |
| (β i, c i β’ rationalWeilDivisor (D i)) (β i, c i β’ rationalWeilDivisor (T i)) := | |
| IsQCartierPullback.sum Finset.univ (fun i _ => ((hT i).rational (hD.1 i).1).smul (c i)) | |
| have he := hQ.unique ((hP.rational hK).add hsumPull) | |
| rw [he, Finsupp.sub_apply, Finsupp.add_apply, Finsupp.finsetSum_apply] | |
| change (-1 : β) < (KW p : β) - ((P p : β) + β i, c i * (T i p : β)) | |
| 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 := snc_boundary_discrepancy_bound W Y.toComplexProjectiveVariety n hW hY | |
| f hf Y.form KW Y.canonical hKW Y.canonical_of_form P hP D hD T hT p | |
| have haQ : (0 : β) β€ (KW p : β) - (P p : β) := by exact_mod_cast ha | |
| have hbQ : (β i, (T i p : β)) β€ (KW p : β) - (P p : β) + 1 := by | |
| exact_mod_cast hb | |
| have hnonneg (i : ΞΉ) : 0 β€ (T i p : β) := by | |
| exact_mod_cast (hT i).nonneg (hD.1 i).2 p | |
| by_cases hzero : β i, T i p = 0 | |
| Β· simp only [hzero, Int.cast_zero, mul_zero, Finset.sum_const_zero, add_zero] | |
| linarith | |
| Β· push Not at hzero | |
| obtain β¨j, hjβ© := hzero | |
| have hjpos : 0 < (T j p : β) := | |
| lt_of_le_of_ne (hnonneg j) (by exact_mod_cast Ne.symm hj) | |
| have hlt : (β i, c i * (T i p : β)) < β i, (T i p : β) := by | |
| apply Finset.sum_lt_sum | |
| Β· intro i _ | |
| nlinarith [hc1 i, hnonneg i] | |
| Β· exact β¨j, Finset.mem_univ _, by nlinarith [hc1 j]β© | |
| linarith | |
| 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 | |
| open AlgebraicGeometry CategoryTheory TopologicalSpace Filter | |
| open Opposite TopCat | |
| open AlgebraicGeometry CategoryTheory TopCat Opposite TopologicalSpace | |
| open CategoryTheory.Limits | |
| namespace NumericalDimensionOne | |
| noncomputable section | |
| def IsSimpleNormalCrossingsDivisorFamilyOver | |
| (Y : Scheme) [IsIntegral Y] [IsLocallyNoetherian Y] [StalkwiseNormal Y] | |
| (sY : Y βΆ Spec (.of β)) (n : β) | |
| {ΞΉ : Type*} [Fintype ΞΉ] (D : ΞΉ β WeilDivisor Y) : Prop := | |
| (β i, IsCartierDivisor (D i) β§ 0 β€ D i) β§ | |
| β x : Y, | |
| letI := schemeStalkAlgebra (.of β) sY x | |
| β (g : β i, CartierStalkEquation (D i) x) | |
| (b : Module.Basis (Fin n) (Y.presheaf.stalk x) Ξ©[(Y.presheaf.stalk x)ββ]) | |
| (S : Finset ΞΉ) (Ο : S βͺ Fin n), | |
| (β i : S, KaehlerDifferential.D β (Y.presheaf.stalk x) (g i.1).regular = b (Ο i)) β§ | |
| (β i β S, IsUnit (g i).regular) | |
| theorem snc_boundary_discrepancy_bound_scheme | |
| (X Y : Scheme) [IsIntegral X] [IsIntegral Y] | |
| [IsLocallyNoetherian X] [IsLocallyNoetherian Y] | |
| [StalkwiseNormal X] [StalkwiseNormal Y] | |
| (sX : X βΆ Spec (.of β)) (sY : Y βΆ Spec (.of β)) (n : β) | |
| [SmoothOfRelativeDimension n sX] [SmoothOfRelativeDimension n sY] | |
| (f : X βΆ Y) [IsDominant f] | |
| (hf : f β« sY = sX) | |
| (Ο : rationalTopForms (.of β) sY n) | |
| (DX : WeilDivisor X) (DY : WeilDivisor Y) | |
| (hDX : IsCanonicalDivisorOf (.of β) sX n | |
| (rationalTopFormPullback (.of β) sX sY f hf n Ο) DX) | |
| (hDY : IsCanonicalDivisorOf (.of β) sY n Ο DY) | |
| (P : WeilDivisor X) (hP : IsCartierPullback f DY P) | |
| {ΞΉ : Type*} [Fintype ΞΉ] (D : ΞΉ β WeilDivisor Y) | |
| (hD : IsSimpleNormalCrossingsDivisorFamilyOver Y sY n D) | |
| (T : ΞΉ β WeilDivisor X) (hT : β i, IsCartierPullback f (D i) (T i)) : | |
| β p : PrimeDivisor X, (β i, T i p) β€ (DX - P) p + 1 := by | |
| classical | |
| intro p | |
| let := schemeStalkAlgebra (.of β) sY (f p.1) | |
| obtain β¨g, b, S, Ο, hcoord, hunitβ© := hD.2 (f p.1) | |
| have hactive := independent_boundary_discrepancy_bound_scheme X Y sX sY n f hf Ο DX DY | |
| hDX hDY P hP (fun i : S => D i.1) (fun i : S => T i.1) | |
| (fun i => hT i.1) p (fun i => g i.1) b Ο hcoord | |
| have hzero (i : ΞΉ) (hi : i β S) : T i p = 0 := by | |
| have hTord := (hT i).order_eq_of_equation (g i).nonzero (g i).equation p (g i).mem_openSet | |
| rw [hTord, β (g i).regular_eq, dominantFunctionFieldMap_algebraMap] | |
| exact order_stalk_unit p ((hunit i hi).map (f.stalkMap p.1).hom) | |
| have hsum : (β i : S, T i.1 p) = β i, T i p := by | |
| rw [Finset.sum_coe_sort S (fun i => T i p)] | |
| exact Finset.sum_subset (Finset.subset_univ _) (fun i _ hi => hzero i hi) | |
| rwa [hsum] at hactive | |
| lemma snc_fractional_discrepancy_bound_scheme | |
| (X Y : Scheme) [IsIntegral X] [IsIntegral Y] | |
| [IsLocallyNoetherian X] [IsLocallyNoetherian Y] | |
| [StalkwiseNormal X] [StalkwiseNormal Y] [CompactSpace X] | |
| (sX : X βΆ Spec (.of β)) (sY : Y βΆ Spec (.of β)) (n : β) | |
| [SmoothOfRelativeDimension n sX] [SmoothOfRelativeDimension n sY] | |
| (f : X βΆ Y) [IsDominant f] (hf : f β« sY = sX) | |
| (Ο : rationalTopForms (.of β) sY n) | |
| (DX : WeilDivisor X) (DY : WeilDivisor Y) | |
| (hDX : IsCanonicalDivisorOf (.of β) sX n | |
| (rationalTopFormPullback (.of β) sX sY f hf n Ο) DX) | |
| (hDY : IsCanonicalDivisorOf (.of β) sY n Ο DY) | |
| {ΞΉ : Type*} [Fintype ΞΉ] (D : ΞΉ β WeilDivisor Y) | |
| (hD : IsSimpleNormalCrossingsDivisorFamilyOver Y sY n D) | |
| (c : ΞΉ β β) (hc1 : β i, c i < 1) | |
| (Q : QWeilDivisor X) | |
| (hQ : IsQCartierPullback f (rationalWeilDivisor DY + β i, c i β’ rationalWeilDivisor (D i)) Q) | |
| (p : PrimeDivisor X) : | |
| (-1 : β) < (DX p : β) - Q p := by | |
| classical | |
| have hK := isCartier_of_isCanonical sY n β¨Ο, hDYβ© | |
| obtain β¨P, hPβ© := exists_cartierPullback f DY hK | |
| have hex (i : ΞΉ) := exists_cartierPullback f (D i) (hD.1 i).1 | |
| choose T hT using hex | |
| have hsumPull : IsQCartierPullback f | |
| (β i, c i β’ rationalWeilDivisor (D i)) (β i, c i β’ rationalWeilDivisor (T i)) := | |
| IsQCartierPullback.sum Finset.univ (fun i _ => ((hT i).rational (hD.1 i).1).smul (c i)) | |
| have he := hQ.unique ((hP.rational hK).add hsumPull) | |
| rw [he, Finsupp.add_apply, Finsupp.finsetSum_apply] | |
| change (-1 : β) < (DX p : β) - ((P p : β) + β i, c i * (T i p : β)) | |
| have ha : 0 β€ DX p - P p := by | |
| obtain β¨v, b, z, _, hn, hzβ© := canonical_ramification_coefficient | |
| X Y sX sY n f hf Ο DX DY hDX hDY P hP p | |
| rw [hz] | |
| exact (ord_nonnegative_iff_regular p _ hn).mpr β¨z, rflβ© | |
| have hb := snc_boundary_discrepancy_bound_scheme X Y sX sY n | |
| f hf Ο DX DY hDX hDY P hP D hD T hT p | |
| have haQ : (0 : β) β€ (DX p : β) - (P p : β) := by exact_mod_cast ha | |
| have hbQ : (β i, (T i p : β)) β€ (DX p : β) - (P p : β) + 1 := by | |
| exact_mod_cast hb | |
| have hnonneg (i : ΞΉ) : 0 β€ (T i p : β) := by | |
| exact_mod_cast (hT i).nonneg (hD.1 i).2 p | |
| by_cases hzero : β i, T i p = 0 | |
| Β· simp only [hzero, Int.cast_zero, mul_zero, Finset.sum_const_zero, add_zero] | |
| linarith | |
| Β· push Not at hzero | |
| obtain β¨j, hjβ© := hzero | |
| have hjpos : 0 < (T j p : β) := | |
| lt_of_le_of_ne (hnonneg j) (by exact_mod_cast Ne.symm hj) | |
| have hlt : (β i, c i * (T i p : β)) < β i, (T i p : β) := by | |
| apply Finset.sum_lt_sum | |
| Β· intro i _ | |
| nlinarith [hc1 i, hnonneg i] | |
| Β· exact β¨j, Finset.mem_univ _, by nlinarith [hc1 j]β© | |
| linarith | |
| end | |
| end NumericalDimensionOne | |
| end OAI | |