lean/OAI/AlgebraicGeometry/SectionFields/GeometricFiber.lean

import Mathlib
import OAI.AlgebraicGeometry.SectionFields.AlgebraicDescent
import OAI.AlgebraicGeometry.SectionFields.TensorDomains

namespace OAI

/-! Geometric integrality of contraction fibres and exact presentations. -/

noncomputable section
open AlgebraicGeometry CategoryTheory CategoryTheory.Limits TopologicalSpace Order Polynomial
open scoped TensorProduct WithZero
universe u

namespace RelativeDenominators
section
attribute [local instance 2000] CommRingCat.commRing
open scoped TensorProduct

 

theorem scalarExtensionChart_domain_of_relatively_closed
    (K A L : Type u) [Field K] [CharZero K] [CommRing A] [IsDomain A] [Field L]
    [Algebra K A] [Algebra K L]
    {X : Scheme.{u}} [IsIntegral X] (f : X ⟶ Spec (.of K))
    (h : letI := (constantToFunctionField K f).toAlgebra
      IsIntegrallyClosedIn K X.functionField)
    (j : Spec (.of A) ⟶ X) [IsOpenImmersion j] [IsDominant j]
    (hj : Spec.map (CommRingCat.ofHom (algebraMap K A)) = j ≫ f) :
    IsDomain (A ⊗[K] L) := by
  let := (constantToFunctionField K f).toAlgebra
  let : IsIntegrallyClosedIn K X.functionField := h
  let : Algebra A (Spec (.of A)).functionField :=
    AlgebraicGeometry.instAlgebraCarrierFunctionFieldSpec (.of A)
  let : IsFractionRing A (Spec (.of A)).functionField :=
    functionField_isFractionRing_of_affine (.of A)
  let e : A →ₐ[K] X.functionField :=
    { toRingHom := (functionFieldOpenEquiv j).symm.toRingHom.comp
        (algebraMap A (Spec (.of A)).functionField)
      commutes' := by
        intro a
        apply (functionFieldPullback j).injective
        change (functionFieldOpenEquiv j)
          ((functionFieldOpenEquiv j).symm (algebraMap A (Spec (.of A)).functionField
            (algebraMap K A a))) = functionFieldPullback j (constantToFunctionField K f a)
        rw [RingEquiv.apply_symm_apply, functionFieldPullback_constant, ← hj,
          constantToFunctionField_spec] }
  have he : Function.Injective e :=
    (functionFieldOpenEquiv j).symm.injective.comp
      (IsFractionRing.injective A (Spec (.of A)).functionField)
  let t := Algebra.TensorProduct.map e (AlgHom.id K L)
  have ht : Function.Injective t := by
    change Function.Injective (LinearMap.rTensor L e.toLinearMap)
    exact Module.Flat.rTensor_preserves_injective_linearMap _ he
  let : IsDomain (X.functionField ⊗[K] L) :=
    tensor_domain_of_relatively_closed K X.functionField L
  exact ht.isDomain t.toRingHom

 

theorem geometricallyIntegral_of_functionField_relatively_closed
    (K : Type u) [Field K] [CharZero K]
    {X : Scheme.{u}} [IsIntegral X] (f : X ⟶ Spec (.of K))
    (h : letI := (constantToFunctionField K f).toAlgebra
      IsIntegrallyClosedIn K X.functionField) : GeometricallyIntegral f := by
  let : ObjectProperty.IsClosedUnderIsomorphisms (C := Scheme.{u}) IsIntegral :=
    ⟨fun e _ => IsIntegral.of_isIso e.hom⟩
  constructor
  rw [geometrically_iff_of_commRing_of_isClosedUnderIsomorphisms]
  intro L _ _
  let g := Spec.map (CommRingCat.ofHom (algebraMap K L))
  let P := pullback f g
  let p : P ⟶ X := pullback.fst f g
  have hchart (A : CommRingCat.{u}) (j : Spec A ⟶ X)
      [IsOpenImmersion j] [Nonempty (Spec A)] [Algebra K A]
      (hj : Spec.map (CommRingCat.ofHom (algebraMap K A)) = j ≫ f) :
      IsDomain (A ⊗[K] L) := by
    let : IsIntegral (Spec A) := isIntegral_of_isOpenImmersion j
    let : IsDomain A := (affine_isIntegral_iff A).mp inferInstance
    let : IsDominant j := isDominant_of_openIntegral j
    exact scalarExtensionChart_domain_of_relatively_closed K A L f h j hj
  let (y : P) : _root_.IsReduced (P.presheaf.stalk y) := by
    let i := X.affineOpenCover.idx (p y)
    let A := X.affineOpenCover.X i
    let j : Spec A ⟶ X := X.affineOpenCover.f i
    let : IsOpenImmersion j := X.affineOpenCover.map_prop i
    have hc : p y ∈ Set.range j := X.affineOpenCover.covers (p y)
    let : Nonempty (Spec A) := ⟨hc.choose⟩
    let k := (Spec.map_surjective (j ≫ f)).choose
    let := k.hom.toAlgebra
    have hj : Spec.map (CommRingCat.ofHom (algebraMap K A)) = j ≫ f :=
      (Spec.map_surjective (j ≫ f)).choose_spec
    let : IsDomain (A ⊗[K] L) := hchart A j hj
    let jl := scalarExtensionChart K A L f j hj
    have hy : y ∈ Set.range jl := by
      rw [scalarExtensionChart_range]
      exact hc
    obtain ⟨y', hy'⟩ := hy
    have hr : _root_.IsReduced (P.presheaf.stalk (jl y')) :=
      isReduced_of_injective (jl.stalkMap y').hom
        (ConcreteCategory.bijective_of_isIso (jl.stalkMap y')).1
    rw [hy'] at hr
    exact hr
  let : AlgebraicGeometry.IsReduced P := isReduced_of_isReduced_stalk P
  let := fieldAffineChartAlgebra K f
  let : IsDomain (fieldAffineChartRing X ⊗[K] L) :=
    scalarExtensionChart_domain_of_relatively_closed K (fieldAffineChartRing X) L f h
      (fieldAffineChartMap X) (fieldAffineChart_algebraMap_spec K f)
  let jl := scalarExtensionChart K (fieldAffineChartRing X) L f
    (fieldAffineChartMap X) (fieldAffineChart_algebraMap_spec K f)
  have hd : DenseRange jl := by
    change Dense (Set.range jl)
    rw [scalarExtensionChart_range]
    exact (fieldAffineChartMap X).denseRange.preimage p.isOpenMap
  have hi : IsIrreducible (Set.range jl) := by
    simpa only [Set.image_univ] using
      (IrreducibleSpace.isIrreducible_univ (Spec (.of (fieldAffineChartRing X ⊗[K] L)))).image
        jl jl.continuous.continuousOn
  let : IrreducibleSpace P := (irreducibleSpace_def _).mpr (by
    change IsIrreducible (Set.univ : Set P)
    rw [← hd.closure_range]
    exact hi.closure)
  exact isIntegral_of_irreducibleSpace_of_isReduced P

end

section
attribute [local instance 2000] CommRingCat.commRing

 

noncomputable def genericPointStalkMap
    {X Z : Scheme} [IsIntegral Z] (f : X ⟶ Z)
    (x : X) (hx : f x = genericPoint Z) : Z.functionField →+* X.presheaf.stalk x :=
  ((Z.presheaf.stalkCongr (Inseparable.of_eq hx)).inv ≫ f.stalkMap x).hom

lemma genericPointStalkMap_compat
    {X Z : Scheme} [IsIntegral X] [IsIntegral Z]
    (f : X ⟶ Z) [IsDominant f] (x : X) (hx : f x = genericPoint Z)
    (a : Z.functionField) :
    algebraMap (X.presheaf.stalk x) X.functionField (genericPointStalkMap f x hx a) =
      functionFieldPullback f a := by
  let e := Z.presheaf.stalkCongr (Inseparable.of_eq hx)
  have he : Z.presheaf.stalkSpecializes ((genericPoint_spec Z).specializes (y := f x) trivial) =
      e.hom := rfl
  have ha : algebraMap (Z.presheaf.stalk (f x)) Z.functionField (e.inv a) = a := by
    change Z.presheaf.stalkSpecializes _ (e.inv a) = a
    rw [he]
    exact congrArg (fun h => h a) e.inv_hom_id
  calc
    _ = algebraMap (X.presheaf.stalk x) X.functionField (f.stalkMap x (e.inv a)) := rfl
    _ = functionFieldPullback f
        (algebraMap (Z.presheaf.stalk (f x)) Z.functionField (e.inv a)) :=
      (functionFieldPullback_stalk f x (e.inv a)).symm
    _ = _ := congrArg (functionFieldPullback f) ha

 

theorem integral_rational_stalk_unit_over_generic
    {X Z : Scheme} [IsIntegral X] [IsIntegral Z]
    (hNX : ∀ x : X, IsIntegrallyClosed (X.presheaf.stalk x))
    (f : X ⟶ Z) [IsDominant f]
    (u : X.functionFieldˣ)
    (hu : letI := (functionFieldPullback f).toAlgebra
      IsIntegral Z.functionField (u : X.functionField))
    (x : X) (hx : f x = genericPoint Z) :
    ∃ s : (X.presheaf.stalk x)ˣ,
      algebraMap (X.presheaf.stalk x) X.functionField (s : X.presheaf.stalk x) =
        (u : X.functionField) := by
  let := (functionFieldPullback f).toAlgebra
  let := (genericPointStalkMap f x hx).toAlgebra
  let : IsScalarTower Z.functionField (X.presheaf.stalk x) X.functionField :=
    IsScalarTower.of_algebraMap_eq fun a => (genericPointStalkMap_compat f x hx a).symm
  let := hNX x
  obtain ⟨s, hs⟩ := IsIntegrallyClosed.algebraMap_eq_of_integral
    (hu.tower_top (A := X.presheaf.stalk x))
  obtain ⟨t, ht⟩ := IsIntegrallyClosed.algebraMap_eq_of_integral
    (hu.inv.tower_top (A := X.presheaf.stalk x))
  have hmul : s * t = 1 := by
    apply IsFractionRing.injective (X.presheaf.stalk x) X.functionField
    rw [map_mul, hs, ht, map_one, mul_inv_cancel₀ (Units.ne_zero u)]
  exact ⟨Units.mkOfMulEqOne s t hmul, hs⟩

 

theorem contraction_functionField_integrallyClosedIn
    {X Z : Scheme} [IsIntegral X] [IsIntegral Z] [IsNoetherian X]
    (hNX : ∀ x : X, IsIntegrallyClosed (X.presheaf.stalk x))
    (f : X ⟶ Z) [IsDominant f] [IsIso f.c] :
    letI := (functionFieldPullback f).toAlgebra
    IsIntegrallyClosedIn Z.functionField X.functionField := by
  let := (functionFieldPullback f).toAlgebra
  apply isIntegrallyClosedIn_iff.mpr
  refine ⟨(functionFieldPullback f).injective, ?_⟩
  intro v hv
  by_cases h0 : v = 0
  · exact ⟨0, by simp [h0]⟩
  let u : X.functionFieldˣ := Units.mk0 v h0
  have hvert : IsVerticalDivisor f (principalDivisor X u) := by
    intro p hp hgen
    obtain ⟨s, hs⟩ := integral_rational_stalk_unit_over_generic hNX f u hv p.1 hgen
    apply hp
    change X.ord (u : X.functionField) p.1 = 0
    apply (X.ord_eq_iff p.2 (Units.ne_zero u)).mpr
    let : Ring.KrullDimLE 1 (X.presheaf.stalk p.1) := krullDimLE_of_coheight_le p.2.le
    change Ring.ordFrac (X.presheaf.stalk p.1) (u : X.functionField) = 1
    rw [← hs]
    exact Ring.ordFrac_of_isUnit s.isUnit
  obtain ⟨w, hw⟩ := rational_function_descends_of_vertical_divisor hNX f u hvert
  exact ⟨(w : Z.functionField), hw⟩


instance fromSpecStalk_generic_dominant (Z : Scheme.{u}) [IsIntegral Z] :
    IsDominant (Z.fromSpecStalk (genericPoint Z)) := by
  constructor
  intro x
  rw [range_fromSpecStalk_generic, (genericPoint_spec Z).def]
  trivial

lemma functionFieldPullback_fromSpecStalk_generic (Z : Scheme.{u}) [IsIntegral Z] :
    functionFieldPullback (Z.fromSpecStalk (genericPoint Z)) =
      constantToFunctionField Z.functionField (𝟙 (Spec Z.functionField)) := by
  ext z
  obtain ⟨U, hU, s, rfl⟩ := Z.presheaf.exists_germ_eq z
  let : Nonempty U := ⟨⟨genericPoint Z, hU⟩⟩
  change functionFieldPullback (Z.fromSpecStalk (genericPoint Z)) (Z.germToFunctionField U s) = _
  rw [functionFieldPullback_germ, Scheme.fromSpecStalk_app hU]
  unfold constantToFunctionField
  simp only [Scheme.Hom.id_appTop, RingHom.comp_apply]
  change ((Spec Z.functionField).presheaf.map (homOfLE le_top).op ≫
    (Spec Z.functionField).germToFunctionField _)
      ((Scheme.ΓSpecIso Z.functionField).inv (Z.presheaf.germ U (genericPoint Z) hU s)) = _
  rw [TopCat.Presheaf.germ_res]
  rfl

 

lemma genericFiber_constant_compat
    {X Z : Scheme.{u}} [IsIntegral X] [IsIntegral Z]
    (f : X ⟶ Z) [IsDominant f] (z : Z.functionField) :
    constantToFunctionField Z.functionField (genericFiberToSpec f) z =
      genericFiberFunctionFieldEquiv f (functionFieldPullback f z) := by
  let η := Z.fromSpecStalk (genericPoint Z)
  let q := genericFiberToSpec f
  let : Subsingleton (Spec Z.functionField) :=
    inferInstanceAs (Subsingleton (PrimeSpectrum Z.functionField))
  let : IsDominant q := ⟨(Function.surjective_to_subsingleton q).denseRange⟩
  have hp : genericFiberι f ≫ f = q ≫ η := pullback.condition
  have heq : (functionFieldPullback (genericFiberι f)).comp (functionFieldPullback f) =
      (functionFieldPullback q).comp (functionFieldPullback η) := by
    rw [← functionFieldPullback_comp, ← functionFieldPullback_comp]
    congr 1
  calc
    constantToFunctionField Z.functionField (genericFiberToSpec f) z =
        functionFieldPullback q (constantToFunctionField Z.functionField
          (𝟙 (Spec Z.functionField)) z) := by
      rw [functionFieldPullback_constant]
      simp [q]
    _ = functionFieldPullback q (functionFieldPullback η z) := by
      rw [functionFieldPullback_fromSpecStalk_generic]
    _ = genericFiberFunctionFieldEquiv f (functionFieldPullback f z) :=
      (RingHom.congr_fun heq z).symm

 

theorem contraction_genericFiber_geometricallyIntegral
    {X Z : Scheme.{u}} [IsIntegral X] [IsIntegral Z] [IsNoetherian X]
    [CharZero Z.functionField]
    (hNX : ∀ x : X, IsIntegrallyClosed (X.presheaf.stalk x))
    (f : X ⟶ Z) [IsDominant f] [IsIso f.c] :
    GeometricallyIntegral (genericFiberToSpec f) := by
  apply geometricallyIntegral_of_functionField_relatively_closed Z.functionField
  let := (constantToFunctionField Z.functionField (genericFiberToSpec f)).toAlgebra
  let := (functionFieldPullback f).toAlgebra
  let := contraction_functionField_integrallyClosedIn hNX f
  let e : X.functionField ≃ₐ[Z.functionField] (genericFiber f).functionField :=
    { genericFiberFunctionFieldEquiv f with
      commutes' := fun z => (genericFiber_constant_compat f z).symm }
  apply isIntegrallyClosedIn_iff.mpr
  refine ⟨(algebraMap Z.functionField (genericFiber f).functionField).injective, ?_⟩
  intro z hz
  obtain ⟨a, ha⟩ := IsIntegrallyClosedIn.algebraMap_eq_of_integral
    (hz.map e.symm.toAlgHom)
  refine ⟨a, ?_⟩
  apply e.symm.injective
  simpa using ha

end

section
open AlgebraicGeometry CategoryTheory CategoryTheory.Limits

 

theorem contraction_exact_presentation_of_geometricGenericFiber_principalization
    {X Z : Scheme.{u}} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] [IsNoetherian Z]
    (hNX : ∀ x : X, IsIntegrallyClosed (X.presheaf.stalk x))
    (hNZ : ∀ z : Z, IsIntegrallyClosed (Z.presheaf.stalk z))
    (f : X ⟶ Z) [IsDominant f] [IsIso f.c] [IsProper f]
    [CharZero Z.functionField]
    (L : Type u) [Field L] [Algebra Z.functionField L] [IsGalois Z.functionField L]
    (A : RationalWeilDivisor X) (hA : IsQCartier X A)
    (D : RationalWeilDivisor Z) (hD : IsQCartier Z D)
    (hlinear : RationallyLinearlyEquivalent X A (pullbackQCartier hNZ f D hD))
    (p : ℕ) (hp : 0 < p)
    :
    letI := contraction_genericFiber_geometricallyIntegral hNX f
    ∀ (u : (pullback (genericFiberToSpec f) (Spec.map
      (CommRingCat.ofHom (algebraMap Z.functionField L)))).functionFieldˣ)
    (_ : letI : IsNoetherian (pullback (genericFiberToSpec f) (Spec.map
        (CommRingCat.ofHom (algebraMap Z.functionField L)))) := {}
      (p : ℚ) • pullbackQCartier (genericFiber_normal f hNX)
        (pullback.fst (genericFiberToSpec f) (Spec.map
          (CommRingCat.ofHom (algebraMap Z.functionField L))))
        (pullbackQCartier hNX (genericFiberι f) A hA)
        (isQCartier_pullback hNX (genericFiberι f) A hA) +
      rationalPrincipalDivisor _ u = 0),
    ∃ (ψ : X.functionFieldˣ) (DZ : RationalWeilDivisor Z) (hDZ : IsQCartier Z DZ),
      RationallyLinearlyEquivalent Z DZ D ∧
      A + (p : ℚ)⁻¹ • rationalPrincipalDivisor X ψ = pullbackQCartier hNZ f DZ hDZ := by
  let := contraction_genericFiber_geometricallyIntegral hNX f
  intro u hu
  exact relative_exact_presentation_of_geometricGenericFiber_principalization
    hNX hNZ f L A hA D hD hlinear p hp u hu

end

 

theorem complex_contraction_exact_presentation_of_geometricGenericFiber_principalization
    {X Z : Scheme.{0}} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] [IsNoetherian Z]
    (hNX : ∀ x : X, IsIntegrallyClosed (X.presheaf.stalk x))
    (hNZ : ∀ z : Z, IsIntegrallyClosed (Z.presheaf.stalk z))
    (f : X ⟶ Z) [IsDominant f] [IsIso f.c] [IsProper f]
    (z : Z ⟶ Spec (.of ℂ))
    (A : RationalWeilDivisor X) (hA : IsQCartier X A)
    (D : RationalWeilDivisor Z) (hD : IsQCartier Z D)
    (hlinear : RationallyLinearlyEquivalent X A (pullbackQCartier hNZ f D hD))
    (p : ℕ) (hp : 0 < p)
    :
    letI := (constantToFunctionField ℂ z).toAlgebra
    letI := Algebra.charZero_of_charZero ℂ Z.functionField
    letI := contraction_genericFiber_geometricallyIntegral hNX f
    ∀ (u : (pullback (genericFiberToSpec f) (Spec.map
      (CommRingCat.ofHom (algebraMap Z.functionField (AlgebraicClosure Z.functionField))))).functionFieldˣ)
    (_ : letI : IsNoetherian (pullback (genericFiberToSpec f) (Spec.map
        (CommRingCat.ofHom (algebraMap Z.functionField (AlgebraicClosure Z.functionField))))) := {}
      (p : ℚ) • pullbackQCartier (genericFiber_normal f hNX)
        (pullback.fst (genericFiberToSpec f) (Spec.map
          (CommRingCat.ofHom (algebraMap Z.functionField (AlgebraicClosure Z.functionField)))))
        (pullbackQCartier hNX (genericFiberι f) A hA)
        (isQCartier_pullback hNX (genericFiberι f) A hA) +
      rationalPrincipalDivisor _ u = 0),
    ∃ (ψ : X.functionFieldˣ) (DZ : RationalWeilDivisor Z) (hDZ : IsQCartier Z DZ),
      RationallyLinearlyEquivalent Z DZ D ∧
      A + (p : ℚ)⁻¹ • rationalPrincipalDivisor X ψ = pullbackQCartier hNZ f DZ hDZ := by
  let := (constantToFunctionField ℂ z).toAlgebra
  let := Algebra.charZero_of_charZero ℂ Z.functionField
  exact contraction_exact_presentation_of_geometricGenericFiber_principalization
    hNX hNZ f (AlgebraicClosure Z.functionField) A hA D hD hlinear p hp

end RelativeDenominators
end

end OAI