| import Mathlib |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open CategoryTheory AlgebraicGeometry |
| open scoped TensorProduct |
|
|
| noncomputable section |
|
|
| open CategoryTheory AlgebraicGeometry |
| open scoped TensorProduct |
|
|
| namespace ReverseLogKodaira |
|
|
| attribute [local instance] MvPolynomial.gradedAlgebra |
|
|
| abbrev complexBase : Scheme := Spec (CommRingCat.of ℂ) |
|
|
| abbrev projectiveGrading (N : ℕ) := MvPolynomial.homogeneousSubmodule (Fin (N + 1)) ℂ |
|
|
| abbrev complexProjectiveSpace (N : ℕ) : Scheme := Proj (projectiveGrading N) |
|
|
| def projectiveConstants (N : ℕ) : ℂ →+* projectiveGrading N 0 where |
| toFun r := ⟨MvPolynomial.C r, MvPolynomial.isHomogeneous_C (Fin (N + 1)) r⟩ |
| map_zero' := Subtype.ext (map_zero MvPolynomial.C) |
| map_one' := Subtype.ext (map_one MvPolynomial.C) |
| map_add' x y := Subtype.ext (map_add MvPolynomial.C x y) |
| map_mul' x y := Subtype.ext (map_mul MvPolynomial.C x y) |
|
|
| def complexProjectiveStructure (N : ℕ) : complexProjectiveSpace N ⟶ complexBase := |
| Proj.toSpecZero (projectiveGrading N) ≫ Spec.map (CommRingCat.ofHom (projectiveConstants N)) |
|
|
| |
| structure SmoothProjectiveVariety where |
| scheme : Scheme |
| structural : scheme ⟶ complexBase |
| dimension : ℕ |
| integral : IsIntegral scheme |
| smooth : SmoothOfRelativeDimension dimension structural |
| projective : ∃ (N : ℕ) (i : scheme ⟶ complexProjectiveSpace N), |
| IsClosedImmersion i ∧ i ≫ complexProjectiveStructure N = structural |
|
|
| attribute [instance] SmoothProjectiveVariety.integral SmoothProjectiveVariety.smooth |
|
|
| namespace SmoothProjectiveVariety |
| |
| instance (X : SmoothProjectiveVariety) : Smooth X.structural := |
| SmoothOfRelativeDimension.smooth X.dimension X.structural |
| |
| |
| def globalConstants (X : SmoothProjectiveVariety) : ℂ →+* Γ(X.scheme, ⊤) := |
| X.structural.appTop.hom.comp (Scheme.ΓSpecIso (CommRingCat.of ℂ)).inv.hom |
| |
| |
| def constants (X : SmoothProjectiveVariety) (U : X.scheme.Opens) : ℂ →+* Γ(X.scheme, U) := |
| (X.scheme.presheaf.map (homOfLE (le_top (a := U))).op).hom.comp X.globalConstants |
| |
| instance (X : SmoothProjectiveVariety) (U : X.scheme.Opens) : Algebra ℂ Γ(X.scheme, U) := |
| (X.constants U).toAlgebra |
| |
| instance (X : SmoothProjectiveVariety) : Nonempty (⊤ : X.scheme.Opens) := |
| ⟨⟨genericPoint X.scheme, by trivial⟩⟩ |
| |
| |
| def functionFieldConstants (X : SmoothProjectiveVariety) : ℂ →+* X.scheme.functionField := |
| (X.scheme.germToFunctionField ⊤).hom.comp X.globalConstants |
| |
| instance (X : SmoothProjectiveVariety) : Algebra ℂ X.scheme.functionField := |
| X.functionFieldConstants.toAlgebra |
| |
| lemma germ_constants (X : SmoothProjectiveVariety) (U : X.scheme.Opens) [Nonempty U] (c : ℂ) : |
| algebraMap Γ(X.scheme, U) X.scheme.functionField (algebraMap ℂ Γ(X.scheme, U) c) = |
| algebraMap ℂ X.scheme.functionField c := by |
| change X.scheme.presheaf.germ U (genericPoint X.scheme) _ |
| (X.scheme.presheaf.map (homOfLE (le_top (a := U))).op (X.globalConstants c)) = |
| X.scheme.presheaf.germ ⊤ (genericPoint X.scheme) _ (X.globalConstants c) |
| exact X.scheme.presheaf.germ_res_apply (homOfLE le_top) (genericPoint X.scheme) _ _ |
| |
| instance (X : SmoothProjectiveVariety) (U : X.scheme.Opens) [Nonempty U] : |
| IsScalarTower ℂ Γ(X.scheme, U) X.scheme.functionField := |
| IsScalarTower.of_algebraMap_eq fun c => (X.germ_constants U c).symm |
| |
| instance affineFiniteType (X : SmoothProjectiveVariety) (U : X.scheme.affineOpens) : |
| Algebra.FiniteType ℂ Γ(X.scheme, U.1) := by |
| change (X.constants U.1).FiniteType |
| have hf := X.structural.finiteType_appLE (isAffineOpen_top _) U.2 (by simp) |
| have he := RingHom.FiniteType.of_surjective |
| (Scheme.ΓSpecIso (CommRingCat.of ℂ)).inv.hom |
| (ConcreteCategory.bijective_of_isIso (Scheme.ΓSpecIso (CommRingCat.of ℂ)).inv).2 |
| exact hf.comp he |
| |
| instance functionFieldFinTrdeg (X : SmoothProjectiveVariety) : |
| FinTrdeg ℂ X.scheme.functionField := by |
| obtain ⟨_, ⟨U, hU, rfl⟩, hx, -⟩ := |
| X.scheme.isBasis_affineOpens.exists_subset_of_mem_open |
| (Set.mem_univ (genericPoint X.scheme)) isOpen_univ |
| let : Nonempty U := ⟨⟨genericPoint X.scheme, hx⟩⟩ |
| let : Algebra.FiniteType ℂ Γ(X.scheme, U) := X.affineFiniteType ⟨U, hU⟩ |
| let := functionField_isFractionRing_of_isAffineOpen X.scheme U hU |
| let := Algebra.EssFiniteType.of_isLocalization X.scheme.functionField |
| (nonZeroDivisors Γ(X.scheme, U)) |
| let := Algebra.EssFiniteType.comp ℂ Γ(X.scheme, U) X.scheme.functionField |
| infer_instance |
| |
| |
| |
| lemma exists_standardSmooth_affine (X : SmoothProjectiveVariety) : |
| ∃ U : X.scheme.affineOpens, Nonempty U.1 ∧ |
| Algebra.IsStandardSmoothOfRelativeDimension X.dimension ℂ Γ(X.scheme, U.1) := by |
| obtain ⟨U, hU, V, hV, hx, e, hf⟩ := |
| SmoothOfRelativeDimension.exists_isStandardSmoothOfRelativeDimension |
| (n := X.dimension) (f := X.structural) (genericPoint X.scheme) |
| have hUt : U = ⊤ := by |
| apply top_unique |
| intro y hy |
| have htt := e hx |
| change X.structural (genericPoint X.scheme) ∈ U at htt |
| simpa only [Subsingleton.elim y (X.structural (genericPoint X.scheme))] using htt |
| subst U |
| refine ⟨⟨V, hV⟩, ⟨⟨genericPoint X.scheme, hx⟩⟩, ?_⟩ |
| rw [← RingHom.isStandardSmoothOfRelativeDimension_algebraMap] |
| exact RingHom.isStandardSmoothOfRelativeDimension_respectsIso.right |
| (X.structural.appLE ⊤ V e).hom |
| (Scheme.ΓSpecIso (CommRingCat.of ℂ)).symm.commRingCatIsoToRingEquiv hf |
| |
| |
| |
| lemma rank_rationalDifferentials (X : SmoothProjectiveVariety) : |
| Module.rank X.scheme.functionField (KaehlerDifferential ℂ X.scheme.functionField) = |
| X.dimension := by |
| obtain ⟨U, hU, hsm⟩ := X.exists_standardSmooth_affine |
| let : Nonempty U.1 := hU |
| let : Algebra.IsStandardSmoothOfRelativeDimension X.dimension ℂ Γ(X.scheme, U.1) := hsm |
| let : Algebra.IsStandardSmooth ℂ Γ(X.scheme, U.1) := |
| Algebra.IsStandardSmoothOfRelativeDimension.isStandardSmooth X.dimension |
| let := functionField_isFractionRing_of_isAffineOpen X.scheme U.1 U.2 |
| let := Algebra.FormallyEtale.of_isLocalization (Rₘ := X.scheme.functionField) |
| (nonZeroDivisors Γ(X.scheme, U.1)) |
| have he := (KaehlerDifferential.tensorKaehlerEquivOfFormallyEtale ℂ Γ(X.scheme, U.1) |
| X.scheme.functionField).rank_eq |
| rw [← he, Module.rank_baseChange, |
| Algebra.IsStandardSmoothOfRelativeDimension.rank_kaehlerDifferential X.dimension] |
| simp |
| |
| instance finite_rationalDifferentials (X : SmoothProjectiveVariety) : |
| Module.Finite X.scheme.functionField (KaehlerDifferential ℂ X.scheme.functionField) := |
| Module.finite_of_rank_eq_nat X.rank_rationalDifferentials |
| |
| lemma finrank_rationalDifferentials (X : SmoothProjectiveVariety) : |
| Module.finrank X.scheme.functionField (KaehlerDifferential ℂ X.scheme.functionField) = |
| X.dimension := by |
| simp [Module.finrank, X.rank_rationalDifferentials] |
| |
| |
| abbrev RationalCanonical (X : SmoothProjectiveVariety) := |
| ⋀[X.scheme.functionField]^X.dimension (KaehlerDifferential ℂ X.scheme.functionField) |
| |
| |
| lemma finrank_rationalCanonical (X : SmoothProjectiveVariety) : |
| Module.finrank X.scheme.functionField X.RationalCanonical = 1 := by |
| rw [RationalCanonical, exteriorPower.finrank_eq, X.finrank_rationalDifferentials] |
| exact Nat.choose_self _ |
| |
| |
| abbrev RationalPluriform (X : SmoothProjectiveVariety) (m : ℕ) := |
| ⨂[X.scheme.functionField]^m X.RationalCanonical |
| |
| instance (X : SmoothProjectiveVariety) (m : ℕ) : AddCommGroup (X.RationalPluriform m) := |
| Module.addCommMonoidToAddCommGroup X.scheme.functionField |
| |
| |
| lemma nonempty_pluriformEquiv (X : SmoothProjectiveVariety) (m : ℕ) : |
| Nonempty (X.RationalPluriform m ≃ₗ[X.scheme.functionField] X.scheme.functionField) := by |
| let e : X.RationalCanonical ≃ₗ[X.scheme.functionField] X.scheme.functionField := |
| LinearEquiv.ofFinrankEq _ _ (by simpa using X.finrank_rationalCanonical) |
| exact ⟨(PiTensorProduct.congr fun _ : Fin m => e).trans |
| (PiTensorProduct.constantBaseRingEquiv (Fin m) X.scheme.functionField).toLinearEquiv⟩ |
| |
| lemma finrank_rationalPluriform (X : SmoothProjectiveVariety) (m : ℕ) : |
| Module.finrank X.scheme.functionField (X.RationalPluriform m) = 1 := by |
| obtain ⟨e⟩ := X.nonempty_pluriformEquiv m |
| simpa using e.finrank_eq |
| |
| instance finite_rationalPluriform (X : SmoothProjectiveVariety) (m : ℕ) : |
| Module.Finite X.scheme.functionField (X.RationalPluriform m) := |
| Module.finite_of_finrank_pos (by rw [X.finrank_rationalPluriform m]; decide) |
| |
| instance nontrivial_rationalPluriform (X : SmoothProjectiveVariety) (m : ℕ) : |
| Nontrivial (X.RationalPluriform m) := |
| (X.nonempty_pluriformEquiv m).some.toEquiv.nontrivial |
| |
| |
| |
| def regularPluriformLattice (X : SmoothProjectiveVariety) (U : X.scheme.affineOpens) |
| [Nonempty U.1] (m : ℕ) : Submodule Γ(X.scheme, U.1) (X.RationalPluriform m) := |
| Submodule.span Γ(X.scheme, U.1) <| Set.range fun a : Fin m → Fin X.dimension → Γ(X.scheme, U.1) => |
| PiTensorProduct.tprod X.scheme.functionField fun j => |
| exteriorPower.ιMulti X.scheme.functionField X.dimension fun i => |
| KaehlerDifferential.D ℂ X.scheme.functionField (algebraMap _ _ (a j i)) |
| |
| |
| |
| def IsCartierIdeal (X : SmoothProjectiveVariety) (I : X.scheme.IdealSheafData) : Prop := |
| ∀ x : X.scheme, ∃ (U : X.scheme.affineOpens), x ∈ U.1 ∧ |
| ∃ t : Γ(X.scheme, U.1), t ≠ 0 ∧ I.ideal U = Ideal.span {t} |
| |
| |
| lemma isCartierIdeal_one (X : SmoothProjectiveVariety) : X.IsCartierIdeal 1 := by |
| intro x |
| obtain ⟨_, ⟨U, hU, rfl⟩, hx, -⟩ := |
| X.scheme.isBasis_affineOpens.exists_subset_of_mem_open (Set.mem_univ x) isOpen_univ |
| let : Nonempty U := ⟨⟨x, hx⟩⟩ |
| refine ⟨⟨U, hU⟩, hx, 1, one_ne_zero, ?_⟩ |
| simp |
| |
| |
| |
| structure ReducedSNCBoundary (X : SmoothProjectiveVariety) where |
| count : ℕ |
| components : Fin count → X.scheme.IdealSheafData |
| cartier : ∀ i, X.IsCartierIdeal (components i) |
| transverse : ∀ S : Finset (Fin count), S.Nonempty → |
| IsEmpty ((S.sup components).subscheme) ∨ |
| (S.card ≤ X.dimension ∧ SmoothOfRelativeDimension (X.dimension - S.card) |
| ((S.sup components).subschemeι ≫ X.structural)) |
| union_cartier : X.IsCartierIdeal (∏ i, components i) |
|
|
| namespace ReducedSNCBoundary |
|
|
| |
| def empty (X : SmoothProjectiveVariety) : X.ReducedSNCBoundary where |
| count := 0 |
| components := Fin.elim0 |
| cartier := fun i => i.elim0 |
| transverse := by |
| intro S hS |
| obtain ⟨i, hi⟩ := hS |
| exact i.elim0 |
| union_cartier := by simpa using X.isCartierIdeal_one |
|
|
| |
| def ideal {X : SmoothProjectiveVariety} (E : X.ReducedSNCBoundary) : X.scheme.IdealSheafData := |
| ∏ i, E.components i |
|
|
| |
| def support {X : SmoothProjectiveVariety} (E : X.ReducedSNCBoundary) : Set X.scheme := |
| E.ideal.support |
|
|
| @[simp] lemma ideal_empty (X : SmoothProjectiveVariety) : (empty X).ideal = 1 := by |
| change (∏ i : Fin 0, Fin.elim0 i) = (1 : X.scheme.IdealSheafData) |
| exact Fin.prod_univ_zero _ |
|
|
| @[simp] lemma support_empty (X : SmoothProjectiveVariety) : (empty X).support = ∅ := by |
| simp [support] |
|
|
| |
|
|
| def IsLogPluriform {X : SmoothProjectiveVariety} (E : X.ReducedSNCBoundary) |
| (m : ℕ) (s : X.RationalPluriform m) : Prop := |
| ∀ (U : X.scheme.affineOpens) (_ : Nonempty U.1) (t : Γ(X.scheme, U.1)), |
| t ≠ 0 → E.ideal.ideal U = Ideal.span {t} → |
| (algebraMap Γ(X.scheme, U.1) X.scheme.functionField t)^m • s ∈ |
| X.regularPluriformLattice U m |
|
|
| lemma isLogPluriform_zero {X : SmoothProjectiveVariety} (E : X.ReducedSNCBoundary) (m : ℕ) : |
| E.IsLogPluriform m 0 := by |
| intro U hU t ht hI |
| simp only [smul_zero, Submodule.zero_mem] |
|
|
| lemma isLogPluriform_add {X : SmoothProjectiveVariety} (E : X.ReducedSNCBoundary) (m : ℕ) |
| {s r : X.RationalPluriform m} (hs : E.IsLogPluriform m s) (hr : E.IsLogPluriform m r) : |
| E.IsLogPluriform m (s + r) := by |
| intro U hU t ht hI |
| simpa only [smul_add] using (X.regularPluriformLattice U m).add_mem |
| (hs U hU t ht hI) (hr U hU t ht hI) |
|
|
| lemma isLogPluriform_smul {X : SmoothProjectiveVariety} (E : X.ReducedSNCBoundary) (m : ℕ) |
| (c : ℂ) {s : X.RationalPluriform m} (hs : E.IsLogPluriform m s) : |
| E.IsLogPluriform m (c • s) := by |
| intro U hU t ht hI |
| have h := (X.regularPluriformLattice U m).smul_mem |
| (algebraMap ℂ Γ(X.scheme, U.1) c) (hs U hU t ht hI) |
| rw [IsScalarTower.algebraMap_smul Γ(X.scheme, U.1)] at h |
| rwa [smul_comm c] at h |
|
|
| |
|
|
| def sections {X : SmoothProjectiveVariety} (E : X.ReducedSNCBoundary) (m : ℕ) : |
| Submodule ℂ (X.RationalPluriform m) where |
| carrier := E.IsLogPluriform m |
| zero_mem' := E.isLogPluriform_zero m |
| add_mem' := E.isLogPluriform_add m |
| smul_mem' := E.isLogPluriform_smul m |
|
|
| |
|
|
| def HasImageDimensionAtLeast {X : SmoothProjectiveVariety} |
| (E : X.ReducedSNCBoundary) (k : ℕ) : Prop := |
| ∃ (m : ℕ), 0 < m ∧ ∃ s : X.RationalPluriform m, |
| s ∈ E.sections m ∧ s ≠ 0 ∧ ∃ r : Fin k → X.scheme.functionField, |
| AlgebraicIndependent ℂ r ∧ ∀ i, r i • s ∈ E.sections m |
|
|
| |
|
|
| def kodaira {X : SmoothProjectiveVariety} (E : X.ReducedSNCBoundary) : WithBot ℕ∞ := |
| ⨆ (k : ℕ) (_ : E.HasImageDimensionAtLeast k), ((k : ℕ∞) : WithBot ℕ∞) |
|
|
| lemma imageDimension_le_transcendenceDegree {X : SmoothProjectiveVariety} |
| (E : X.ReducedSNCBoundary) {k : ℕ} (hk : E.HasImageDimensionAtLeast k) : |
| k ≤ (Algebra.trdeg ℂ X.scheme.functionField).toNat := by |
| rcases hk with ⟨m, hm, s, hs, hn, r, hr, hmem⟩ |
| have h := Cardinal.toNat_le_toNat hr.cardinalMk_le_trdeg |
| (trdeg_lt_aleph0 ℂ X.scheme.functionField) |
| simpa using h |
|
|
| lemma kodaira_le_transcendenceDegree {X : SmoothProjectiveVariety} |
| (E : X.ReducedSNCBoundary) : |
| E.kodaira ≤ (((Algebra.trdeg ℂ X.scheme.functionField).toNat : ℕ∞) : WithBot ℕ∞) := by |
| apply iSup_le |
| intro k |
| apply iSup_le |
| intro hk |
| exact_mod_cast E.imageDimension_le_transcendenceDegree hk |
|
|
| |
| lemma kodaira_ne_top {X : SmoothProjectiveVariety} (E : X.ReducedSNCBoundary) : |
| E.kodaira ≠ ⊤ := by |
| apply ne_of_lt |
| exact lt_of_le_of_lt E.kodaira_le_transcendenceDegree (by |
| exact WithBot.coe_lt_coe.mpr (ENat.natCast_lt_top _)) |
|
|
| lemma hasImageDimensionAtLeast_zero_iff {X : SmoothProjectiveVariety} |
| (E : X.ReducedSNCBoundary) : |
| E.HasImageDimensionAtLeast 0 ↔ ∃ (m : ℕ), 0 < m ∧ |
| ∃ s : X.RationalPluriform m, s ∈ E.sections m ∧ s ≠ 0 := by |
| constructor |
| · rintro ⟨m, hm, s, hs, hn, r, hr, h⟩ |
| exact ⟨m, hm, s, hs, hn⟩ |
| · rintro ⟨m, hm, s, hs, hn⟩ |
| exact ⟨m, hm, s, hs, hn, Fin.elim0, algebraicIndependent_empty_type, fun i => i.elim0⟩ |
|
|
| |
| theorem kodaira_eq_bot_iff {X : SmoothProjectiveVariety} (E : X.ReducedSNCBoundary) : |
| E.kodaira = ⊥ ↔ ∀ (m : ℕ), 0 < m → |
| ∀ s : X.RationalPluriform m, s ∈ E.sections m → s = 0 := by |
| constructor |
| · intro h m hm s hs |
| by_contra hn |
| have hzero := E.hasImageDimensionAtLeast_zero_iff.mpr ⟨m, hm, s, hs, hn⟩ |
| have hle : ((0 : ℕ∞) : WithBot ℕ∞) ≤ E.kodaira := |
| le_iSup_of_le 0 (le_iSup_of_le hzero le_rfl) |
| rw [h] at hle |
| exact WithBot.coe_ne_bot (le_bot_iff.mp hle) |
| · intro h |
| apply le_bot_iff.mp |
| apply iSup_le |
| intro k |
| apply iSup_le |
| rintro ⟨m, hm, s, hs, hn, r, hr, hmem⟩ |
| exact (hn (h m hm s hs)).elim |
|
|
| end ReducedSNCBoundary |
|
|
| |
| structure ComplexPoint (X : SmoothProjectiveVariety) where |
| hom : complexBase ⟶ X.scheme |
| over_base : hom ≫ X.structural = 𝟙 complexBase |
|
|
| |
| def complexBasePoint : complexBase := ⟨⊥, Ideal.isPrime_bot⟩ |
|
|
| |
| def ComplexPoint.point {X : SmoothProjectiveVariety} (y : X.ComplexPoint) : X.scheme := |
| y.hom complexBasePoint |
|
|
| |
| def ReducedSNCBoundary.complement {X : SmoothProjectiveVariety} (E : X.ReducedSNCBoundary) : |
| X.scheme.Opens := E.ideal.support.compl |
|
|
| |
|
|
| structure BoundaryFibration (X Y : SmoothProjectiveVariety) |
| (E : X.ReducedSNCBoundary) (D : Y.ReducedSNCBoundary) where |
| hom : X.scheme ⟶ Y.scheme |
| over_base : hom ≫ Y.structural = X.structural |
| surjective : Surjective hom |
| connected : ∀ y : Y.ComplexPoint, ConnectedSpace ↥(CategoryTheory.Limits.pullback hom y.hom) |
| support : hom ⁻¹' D.support ⊆ E.support |
|
|
| |
|
|
| structure StratumSmoothFibration (X Y : SmoothProjectiveVariety) |
| (E : X.ReducedSNCBoundary) (D : Y.ReducedSNCBoundary) |
| extends BoundaryFibration X Y E D where |
| smooth : Smooth (hom.resLE D.complement (hom ⁻¹ᵁ D.complement) le_rfl) |
| strata : ∀ (S : Finset (Fin E.count)), S.Nonempty → |
| Smooth (((S.sup E.components).subschemeι ≫ hom).resLE D.complement |
| (((S.sup E.components).subschemeι ≫ hom) ⁻¹ᵁ D.complement) le_rfl) |
|
|
| |
|
|
| structure FiberModel {X Y : SmoothProjectiveVariety} {E : X.ReducedSNCBoundary} |
| {D : Y.ReducedSNCBoundary} (f : BoundaryFibration X Y E D) (y : Y.ComplexPoint) where |
| variety : SmoothProjectiveVariety |
| inclusion : variety.scheme ⟶ X.scheme |
| square : IsPullback inclusion variety.structural f.hom y.hom |
| boundary : variety.ReducedSNCBoundary |
| boundary_pullback : boundary.ideal = E.ideal.comap inclusion |
|
|
| |
|
|
| def VeryGenerally (Y : SmoothProjectiveVariety) (P : Y.ComplexPoint → Prop) : Prop := |
| ∃ Z : ℕ → TopologicalSpace.Closeds Y.scheme, |
| (∀ n, Z n ≠ ⊤) ∧ ∀ y : Y.ComplexPoint, (∀ n, y.point ∉ Z n) → P y |
|
|
| end SmoothProjectiveVariety |
|
|
| open SmoothProjectiveVariety |
|
|
| |
|
|
| def ReverseInequalityStatement : Prop := |
| ∀ (X Y : SmoothProjectiveVariety) (E : X.ReducedSNCBoundary) (D : Y.ReducedSNCBoundary) |
| (f : StratumSmoothFibration X Y E D), |
| VeryGenerally Y fun y => y.point ∈ D.complement ∧ |
| Nonempty (FiberModel f.toBoundaryFibration y) ∧ |
| ∀ F : FiberModel f.toBoundaryFibration y, |
| E.kodaira ≤ D.kodaira + F.boundary.kodaira ∧ |
| ((D.kodaira = ⊥ ∨ F.boundary.kodaira = ⊥) → |
| ∀ (m : ℕ), 0 < m → ∀ s : X.RationalPluriform m, s ∈ E.sections m → s = 0) |
|
|
| |
|
|
| def LogarithmicSubadditivityStatement : Prop := |
| ∀ (X Y : SmoothProjectiveVariety) (E : X.ReducedSNCBoundary) (D : Y.ReducedSNCBoundary) |
| (f : BoundaryFibration X Y E D), |
| VeryGenerally Y fun y => y.point ∈ D.complement ∧ |
| Nonempty (FiberModel f y) ∧ ∀ F : FiberModel f y, |
| D.kodaira + F.boundary.kodaira ≤ E.kodaira |
|
|
| |
| def LogarithmicAdditivityStatement : Prop := |
| ∀ (X Y : SmoothProjectiveVariety) (E : X.ReducedSNCBoundary) (D : Y.ReducedSNCBoundary) |
| (f : StratumSmoothFibration X Y E D), |
| VeryGenerally Y fun y => y.point ∈ D.complement ∧ |
| Nonempty (FiberModel f.toBoundaryFibration y) ∧ |
| ∀ F : FiberModel f.toBoundaryFibration y, |
| E.kodaira = D.kodaira + F.boundary.kodaira |
|
|
| |
|
|
| def MainTheoremStatement : Prop := |
| ReverseInequalityStatement ∧ LogarithmicSubadditivityStatement ∧ LogarithmicAdditivityStatement |
|
|
| end ReverseLogKodaira |
|
|
| namespace ReverseLogKodaira.SmoothProjectiveVariety |
|
|
| |
|
|
| theorem appLE_constants {X Y : SmoothProjectiveVariety} |
| (f : X.scheme ⟶ Y.scheme) (hf : f ≫ Y.structural = X.structural) |
| (U : Y.scheme.Opens) (V : X.scheme.Opens) (e : V ≤ f ⁻¹ᵁ U) (c : ℂ) : |
| f.appLE U V e (Y.constants U c) = X.constants V c := by |
| have hY : Y.constants U = (Y.structural.appLE ⊤ U (by simp)).hom.comp |
| (Scheme.ΓSpecIso (CommRingCat.of ℂ)).inv.hom := rfl |
| have hX : X.constants V = (X.structural.appLE ⊤ V (by simp)).hom.comp |
| (Scheme.ΓSpecIso (CommRingCat.of ℂ)).inv.hom := rfl |
| rw [hY, hX] |
| change (Y.structural.appLE ⊤ U (by simp) ≫ f.appLE U V e) |
| ((Scheme.ΓSpecIso (CommRingCat.of ℂ)).inv c) = _ |
| have h := Scheme.Hom.appLE_comp_appLE f Y.structural ⊤ U V (by simp) e |
| have h' := congrArg (fun g : Γ(complexBase, ⊤) ⟶ Γ(X.scheme, V) => |
| g ((Scheme.ΓSpecIso (CommRingCat.of ℂ)).inv c)) h |
| change _ = (f ≫ Y.structural).appLE ⊤ V _ _ at h' |
| rw [hf] at h' |
| exact h' |
|
|
| end ReverseLogKodaira.SmoothProjectiveVariety |
|
|
| namespace ReverseLogKodaira.SmoothProjectiveVariety |
|
|
| lemma complexPoint_preimage_top {Y : SmoothProjectiveVariety} (y : Y.ComplexPoint) |
| (U : Y.scheme.Opens) (hy : y.point ∈ U) : (⊤ : complexBase.Opens) ≤ y.hom ⁻¹ᵁ U := by |
| intro z hz |
| change y.hom z ∈ U |
| rw [Subsingleton.elim z complexBasePoint] |
| exact hy |
|
|
| |
| def complexPointEvaluation {Y : SmoothProjectiveVariety} (y : Y.ComplexPoint) |
| (U : Y.scheme.Opens) (hy : y.point ∈ U) : Γ(Y.scheme, U) →+* ℂ := |
| (Scheme.ΓSpecIso (CommRingCat.of ℂ)).hom.hom.comp |
| (y.hom.appLE U ⊤ (complexPoint_preimage_top y U hy)).hom |
|
|
| |
|
|
| def chartToFunctionField {X F : SmoothProjectiveVariety} |
| (i : F.scheme ⟶ X.scheme) (V : X.scheme.Opens) [Nonempty (i ⁻¹ᵁ V)] : |
| Γ(X.scheme, V) →+* F.scheme.functionField := |
| (F.scheme.germToFunctionField (i ⁻¹ᵁ V)).hom.comp (i.app V).hom |
|
|
| end ReverseLogKodaira.SmoothProjectiveVariety |
|
|
| namespace ReverseLogKodaira.SmoothProjectiveVariety |
|
|
| lemma complexPointEvaluation_constants {Y : SmoothProjectiveVariety} (y : Y.ComplexPoint) |
| (U : Y.scheme.Opens) (hy : y.point ∈ U) (c : ℂ) : |
| complexPointEvaluation y U hy (Y.constants U c) = c := by |
| have h := Scheme.Hom.appLE_comp_appLE y.hom Y.structural ⊤ U ⊤ (by simp) |
| (complexPoint_preimage_top y U hy) |
| rw [y.over_base] at h |
| have h' := congrArg (fun g : Γ(complexBase, ⊤) ⟶ Γ(complexBase, ⊤) => |
| g ((Scheme.ΓSpecIso (CommRingCat.of ℂ)).inv c)) h |
| have hid : Scheme.Hom.appLE (𝟙 complexBase) ⊤ ⊤ (by simp) = 𝟙 Γ(complexBase, ⊤) := by |
| change (𝟙 Γ(complexBase, ⊤)) ≫ complexBase.presheaf.map (𝟙 _) = _ |
| rw [CategoryTheory.Functor.map_id, Category.id_comp] |
| rw [hid] at h' |
| have hval : y.hom.appLE U ⊤ (complexPoint_preimage_top y U hy) |
| (Y.constants U c) = (Scheme.ΓSpecIso (CommRingCat.of ℂ)).inv c := h' |
| change (Scheme.ΓSpecIso (CommRingCat.of ℂ)).hom |
| (y.hom.appLE U ⊤ (complexPoint_preimage_top y U hy) (Y.constants U c)) = c |
| rw [hval] |
| exact (Scheme.ΓSpecIso (CommRingCat.of ℂ)).inv_hom_id_apply c |
|
|
| lemma chartToFunctionField_constants {X F : SmoothProjectiveVariety} |
| (i : F.scheme ⟶ X.scheme) (hi : i ≫ X.structural = F.structural) |
| (V : X.scheme.Opens) [Nonempty (i ⁻¹ᵁ V)] (c : ℂ) : |
| chartToFunctionField i V (X.constants V c) = algebraMap ℂ F.scheme.functionField c := by |
| have h := appLE_constants i hi V (i ⁻¹ᵁ V) le_rfl c |
| rw [Scheme.Hom.appLE_eq_app] at h |
| change F.scheme.germToFunctionField (i ⁻¹ᵁ V) (i.app V (X.constants V c)) = _ |
| rw [h] |
| exact F.germ_constants (i ⁻¹ᵁ V) c |
|
|
| end ReverseLogKodaira.SmoothProjectiveVariety |
|
|
| namespace ReverseLogKodaira.SmoothProjectiveVariety |
|
|
| theorem fiber_scalar_compatibility : |
| (∀ (Y : SmoothProjectiveVariety) (y : Y.ComplexPoint) |
| (U : Y.scheme.Opens) (hy : y.point ∈ U) (c : ℂ), |
| complexPointEvaluation y U hy (Y.constants U c) = c) ∧ |
| (∀ (X F : SmoothProjectiveVariety) (i : F.scheme ⟶ X.scheme) |
| (_hi : i ≫ X.structural = F.structural) (V : X.scheme.Opens) |
| (_ : Nonempty (i ⁻¹ᵁ V)) (c : ℂ), |
| chartToFunctionField i V (X.constants V c) = algebraMap ℂ F.scheme.functionField c) := by |
| exact ⟨fun _ => complexPointEvaluation_constants, |
| fun _ _ i hi V hV => @chartToFunctionField_constants _ _ i hi V hV⟩ |
|
|
| end ReverseLogKodaira.SmoothProjectiveVariety |
|
|
| namespace ReverseLogKodaira.SmoothProjectiveVariety |
|
|
| |
|
|
| theorem fiber_chart_base_scalar |
| {X Y : SmoothProjectiveVariety} {E : X.ReducedSNCBoundary} {D : Y.ReducedSNCBoundary} |
| (f : BoundaryFibration X Y E D) (y : Y.ComplexPoint) (F : FiberModel f y) |
| (U : Y.scheme.Opens) (hy : y.point ∈ U) (V : X.scheme.Opens) |
| (e : V ≤ f.hom ⁻¹ᵁ U) [Nonempty (F.inclusion ⁻¹ᵁ V)] (a : Γ(Y.scheme, U)) : |
| chartToFunctionField F.inclusion V (f.hom.appLE U V e a) = |
| algebraMap ℂ F.variety.scheme.functionField (complexPointEvaluation y U hy a) := by |
| let W := F.inclusion ⁻¹ᵁ V |
| have h₁ := Scheme.Hom.appLE_comp_appLE F.inclusion f.hom U V W e le_rfl |
| have h₂ := Scheme.Hom.appLE_comp_appLE F.variety.structural y.hom U ⊤ W |
| (complexPoint_preimage_top y U hy) (by simp) |
| have hc : ∀ (g h : F.variety.scheme ⟶ Y.scheme) (hg : g = h) |
| (eg : W ≤ g ⁻¹ᵁ U) (eh : W ≤ h ⁻¹ᵁ U), |
| g.appLE U W eg = h.appLE U W eh := by |
| intro g h hg eg eh |
| subst h |
| rfl |
| have h := h₁.trans ((hc _ _ F.square.w _ _).trans h₂.symm) |
| have hv := congrArg (fun g : Γ(Y.scheme, U) ⟶ Γ(F.variety.scheme, W) => g a) h |
| have hid : (Scheme.ΓSpecIso (CommRingCat.of ℂ)).inv |
| (complexPointEvaluation y U hy a) = y.hom.appLE U ⊤ (complexPoint_preimage_top y U hy) a := |
| (Scheme.ΓSpecIso (CommRingCat.of ℂ)).hom_inv_id_apply _ |
| have ha : F.inclusion.app V (f.hom.appLE U V e a) = |
| F.variety.constants W (complexPointEvaluation y U hy a) := by |
| rw [Scheme.Hom.appLE_eq_app] at hv |
| change _ = F.variety.structural.appLE ⊤ W (by simp) |
| ((Scheme.ΓSpecIso (CommRingCat.of ℂ)).inv (complexPointEvaluation y U hy a)) |
| rw [hid] |
| exact hv |
| change F.variety.scheme.germToFunctionField W |
| (F.inclusion.app V (f.hom.appLE U V e a)) = _ |
| rw [ha] |
| exact F.variety.germ_constants W (complexPointEvaluation y U hy a) |
|
|
| end ReverseLogKodaira.SmoothProjectiveVariety |
|
|
| end |
| end |
|
|
| end OAI |
|
|
