/- Copyright 2026 The Formal Conjectures Authors. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at https://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. This file has been modified. -/ 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