lean/OAI/AlgebraicGeometry/SectionFields/Recovery.lean

import Mathlib
import OAI.AlgebraicGeometry.SectionFields.GeometricFiber

namespace OAI

/-! Complete divisorial section fields, containment and conditional recovery. -/

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

namespace RelativeDenominators

 

theorem exists_stalk_element_of_ord_nonneg
    (X : Scheme) [IsIntegral X] [IsLocallyNoetherian X]
    (x : X) (hx : coheight x = 1) [IsIntegrallyClosed (X.presheaf.stalk x)]
    (u : X.functionField) (hu : u ≠ 0) (hord : 0 ≤ X.ord u x) :
    ∃ a : X.presheaf.stalk x, algebraMap _ X.functionField a = u := by
  let : IsDiscreteValuationRing (X.presheaf.stalk x) :=
    dvr_stalk_of_normal_codimOne X x hx
  have h : (1 : ℤᵐ⁰) ≤ Ring.ordFrac (X.presheaf.stalk x) u :=
    (X.le_ord_iff hx hu).mp hord
  rw [Ring.ordFrac_eq_valuation_inv] at h
  apply IsDiscreteValuationRing.exists_lift_of_le_one
  exact (one_le_inv₀ (by simpa only [zero_lt_iff, Valuation.ne_zero_iff] using hu)).mp h

 
theorem exists_affine_section_of_ord_nonneg
    (X : Scheme) [IsIntegral X] [IsNoetherian X]
    (hNormal : ∀ x : X, IsIntegrallyClosed (X.presheaf.stalk x))
    (U : X.Opens) (hU : IsAffineOpen U) [Nonempty U]
    (f : X.functionField) (hf : f ≠ 0)
    (hord : ∀ x : X, x ∈ U → coheight x = 1 → 0 ≤ X.ord f x) :
    ∃ s : Γ(X, U), algebraMap Γ(X, U) X.functionField s = f := by
  let : IsIntegrallyClosed Γ(X, U) := integrallyClosed_affine_sections X hNormal U hU
  let : IsNoetherianRing Γ(X, U) := IsLocallyNoetherian.component_noetherian ⟨U, hU⟩
  let : IsFractionRing Γ(X, U) X.functionField :=
    functionField_isFractionRing_of_isAffineOpen X U hU
  apply exists_algebraMap_eq_of_mem_height_one_localizations
  intro P hP hheight
  let y : PrimeSpectrum Γ(X, U) := ⟨P, hP⟩
  let z : X := hU.fromSpec y
  have hzU : z ∈ U := (hU.isoSpec.inv y).2
  have hz : coheight z = 1 := by
    change coheight (hU.fromSpec y) = 1
    erw [coheight_eq_of_isOpenImmersion hU.fromSpec,
      ← idealHeight_eq_coheight Γ(X, U) y]
    exact hheight
  let : IsIntegrallyClosed (X.presheaf.stalk z) := hNormal z
  obtain ⟨s, hs⟩ := exists_stalk_element_of_ord_nonneg X z hz f hf (hord z hzU hz)
  let : Algebra Γ(X, U) (X.presheaf.stalk z) :=
    X.presheaf.algebra_section_stalk ⟨z, hzU⟩
  let : IsLocalization.AtPrime (X.presheaf.stalk z) P := hU.isLocalization_stalk' y hzU
  have : IsScalarTower Γ(X, U) (X.presheaf.stalk z) X.functionField :=
    functionField_isScalarTower X U ⟨z, hzU⟩
  obtain ⟨a, b, he⟩ := IsLocalization.exists_mk'_eq P.primeCompl s
  rw [mem_localization_iff_denominator]
  refine ⟨b, b.property, ?_⟩
  rw [Submodule.mem_colon_singleton, Algebra.smul_def]
  refine ⟨a, ?_⟩
  change algebraMap Γ(X, U) X.functionField a = algebraMap Γ(X, U) X.functionField b * f
  rw [← hs, IsScalarTower.algebraMap_apply Γ(X, U) (X.presheaf.stalk z) X.functionField b,
    ← map_mul, ← he, IsLocalization.mk'_spec',
    ← IsScalarTower.algebraMap_apply Γ(X, U) (X.presheaf.stalk z) X.functionField]

 
theorem exists_section_of_ord_nonneg
    (X : Scheme) [IsIntegral X] [IsNoetherian X]
    (hNormal : ∀ x : X, IsIntegrallyClosed (X.presheaf.stalk x))
    (V : X.Opens) [hV : Nonempty V]
    (f : X.functionField) (hf : f ≠ 0)
    (hord : ∀ x : X, x ∈ V → coheight x = 1 → 0 ≤ X.ord f x) :
    ∃ s : Γ(X, V), algebraMap Γ(X, V) X.functionField s = f := by
  classical
  choose U hU hxU hUV using fun x : V => exists_isAffineOpen_mem_and_subset x.property
  let : ∀ x : V, Nonempty (U x) := fun x => ⟨⟨x, hxU x⟩⟩
  choose s hs using fun x : V => exists_affine_section_of_ord_nonneg X hNormal (U x) (hU x)
    f hf (fun y hy => hord y (hUV x hy))
  have hgen : ∀ x : V, genericPoint X ∈ U x := fun x =>
    ((genericPoint_spec X).mem_open_set_iff (U x).isOpen).mpr ⟨x, trivial, hxU x⟩
  have hcover : V ≤ iSup U := by
    intro x hx
    exact Opens.mem_iSup.mpr ⟨⟨x, hx⟩, hxU ⟨x, hx⟩⟩
  have hcompat : TopCat.Presheaf.IsCompatible X.presheaf U s := by
    intro i j
    let : Nonempty ((U i ⊓ U j : X.Opens) : Set X) :=
      ⟨⟨genericPoint X, hgen i, hgen j⟩⟩
    apply @Scheme.germToFunctionField_injective X _ (U i ⊓ U j)
      ⟨⟨genericPoint X, hgen i, hgen j⟩⟩
    rw [germToFunctionField_map, germToFunctionField_map]
    exact (hs i).trans (hs j).symm
  obtain ⟨g, hg, _⟩ := X.sheaf.existsUnique_gluing' U V
    (fun x => homOfLE (hUV x)) hcover s hcompat
  refine ⟨g, ?_⟩
  let x : V := hV.some
  have he := hg x
  have he' := congrArg (X.germToFunctionField (U x)) he
  change X.germToFunctionField (U x)
    (X.presheaf.map (homOfLE (hUV x)).op g) =
      X.germToFunctionField (U x) (s x) at he'
  erw [germToFunctionField_map] at he'
  exact he'.trans (hs x)

 

theorem rational_function_descends_of_no_horizontal_poles
    {X Z : Scheme} [IsIntegral X] [IsIntegral Z] [IsNoetherian X]
    (hNormal : ∀ x : X, IsIntegrallyClosed (X.presheaf.stalk x))
    (f : X ⟶ Z) [IsDominant f] [IsIso f.c]
    (u : X.functionFieldˣ)
    (hhoriz : ∀ p : PrimeDivisor X, f p.1 = genericPoint Z →
      0 ≤ X.ord (u : X.functionField) p.1) :
    ∃ v : Z.functionFieldˣ,
      functionFieldPullback f (v : Z.functionField) = (u : X.functionField) := by
  classical
  let N := (principalDivisor X u).filter (fun p => X.ord (u : X.functionField) p.1 < 0)
  have hN : IsVerticalDivisor f N := by
    intro p hp hgen
    apply hp
    simp [N, not_lt.mpr (hhoriz p hgen)]
  obtain ⟨U, hgen, hU⟩ := exists_open_avoiding_vertical_divisor f N hN
  let : Nonempty U := ⟨⟨genericPoint Z, hgen⟩⟩
  obtain ⟨s, hs⟩ := exists_section_of_ord_nonneg X hNormal (f ⁻¹ᵁ U)
    (u : X.functionField) (Units.ne_zero u) (by
      intro x hx hcodim
      have he := hU ⟨x, hcodim⟩ hx
      by_contra hn
      have hn' : X.ord (u : X.functionField) x < 0 := lt_of_not_ge hn
      have he' : X.ord (u : X.functionField) x = 0 := by simpa [N, hn'] using he
      exact hn'.ne he')
  let t : Γ(Z, U) := inv (f.app U) s
  have ht : f.app U t = s := by
    exact congrArg (fun g => g s) (IsIso.inv_hom_id (f.app U))
  have he : functionFieldPullback f (Z.germToFunctionField U t) = (u : X.functionField) := by
    rw [functionFieldPullback_germ, ht]
    exact hs
  have hv : Z.germToFunctionField U t ≠ 0 := by
    intro h
    apply Units.ne_zero u
    rw [← he, h, map_zero]
  exact ⟨Units.mk0 (Z.germToFunctionField U t) hv, he⟩

 

 

def divisorialSections (X : Scheme) [IsIntegral X] [IsNoetherian X]
    (A : RationalWeilDivisor X) : Set X.functionFieldˣ :=
  { u | ∀ p : PrimeDivisor X, 0 ≤ X.ord (u : X.functionField) p.1 + ⌊A p⌋ }

 
def sectionField (X : Scheme) [IsIntegral X] [IsNoetherian X]
    (A : RationalWeilDivisor X) : Subfield X.functionField :=
  Subfield.closure { t | ∃ u ∈ divisorialSections X A, ∃ v ∈ divisorialSections X A,
    t = (u : X.functionField) / (v : X.functionField) }

 

theorem mem_divisorialSections_iff
    (X : Scheme) [IsIntegral X] [IsNoetherian X]
    (A : RationalWeilDivisor X) (u : X.functionFieldˣ) :
    u ∈ divisorialSections X A ↔
      ∀ p : PrimeDivisor X, 0 ≤ A p + (X.ord (u : X.functionField) p.1 : ℚ) := by
  unfold divisorialSections
  change (∀ p, _) ↔ _
  apply forall_congr'
  intro p
  constructor
  · intro h
    have hi : -X.ord (u : X.functionField) p.1 ≤ ⌊A p⌋ := by omega
    have hq := Int.le_floor.mp hi
    push_cast at hq
    linarith
  · intro h
    have hq : ((-X.ord (u : X.functionField) p.1 : ℤ) : ℚ) ≤ A p := by
      push_cast
      linarith
    have hi := Int.le_floor.mpr hq
    omega

theorem mul_mem_divisorialSections
    (X : Scheme) [IsIntegral X] [IsNoetherian X]
    {A B : RationalWeilDivisor X} {u v : X.functionFieldˣ}
    (hu : u ∈ divisorialSections X A) (hv : v ∈ divisorialSections X B) :
    u * v ∈ divisorialSections X (A + B) := by
  rw [mem_divisorialSections_iff] at hu hv ⊢
  intro p
  have h := add_nonneg (hu p) (hv p)
  simpa only [Finsupp.add_apply, Units.val_mul, X.ord_mul (Units.ne_zero u) (Units.ne_zero v),
    Int.cast_add] using (by linarith : 0 ≤ A p + B p + ((X.ord (u : X.functionField) p.1 : ℚ) +
      (X.ord (v : X.functionField) p.1 : ℚ)))

theorem pow_mem_divisorialSections
    (X : Scheme) [IsIntegral X] [IsNoetherian X]
    {A : RationalWeilDivisor X} {u : X.functionFieldˣ}
    (hu : u ∈ divisorialSections X A) (n : ℕ) :
    u ^ n ∈ divisorialSections X ((n : ℚ) • A) := by
  rw [mem_divisorialSections_iff] at hu ⊢
  intro p
  simpa only [Finsupp.smul_apply, smul_eq_mul, Units.val_pow_eq_pow_val,
    ord_pow X _ (Units.ne_zero u), Int.cast_mul, Int.cast_natCast, mul_add]
    using mul_nonneg (Nat.cast_nonneg n : (0 : ℚ) ≤ n) (hu p)

 

theorem sectionField_le_positive_multiple
    (X : Scheme) [IsIntegral X] [IsNoetherian X]
    (A : RationalWeilDivisor X) (n : ℕ) (hn : 0 < n) :
    sectionField X A ≤ sectionField X ((n : ℚ) • A) := by
  apply Subfield.closure_le.mpr
  rintro t ⟨u, hu, v, hv, rfl⟩
  obtain ⟨k, rfl⟩ := Nat.exists_eq_succ_of_ne_zero hn.ne'
  have hA : ((k + 1 : ℕ) : ℚ) • A = A + (k : ℚ) • A := by
    rw [Nat.cast_add, Nat.cast_one, add_smul, one_smul, add_comm]
  apply Subfield.subset_closure
  refine ⟨u * v ^ k, ?_, v * v ^ k, ?_, ?_⟩
  · rw [hA]
    exact mul_mem_divisorialSections X hu (pow_mem_divisorialSections X hv k)
  · rw [hA]
    exact mul_mem_divisorialSections X hv (pow_mem_divisorialSections X hv k)
  · simp only [Units.val_mul, Units.val_pow_eq_pow_val]
    rw [mul_div_mul_right _ _ (pow_ne_zero _ (Units.ne_zero v))]

theorem divisorialSections_nonempty_positive_multiple
    (X : Scheme) [IsIntegral X] [IsNoetherian X]
    (A : RationalWeilDivisor X) (n : ℕ)
    (h : (divisorialSections X A).Nonempty) :
    (divisorialSections X ((n : ℚ) • A)).Nonempty := by
  obtain ⟨u, hu⟩ := h
  exact ⟨u ^ n, pow_mem_divisorialSections X hu n⟩

 
theorem ord_nonneg_of_section
    (X : Scheme) [IsIntegral X] [IsNoetherian X]
    (U : X.Opens) [Nonempty U] (s : Γ(X, U)) (hs : s ≠ 0)
    (x : X) (hx : x ∈ U) : 0 ≤ X.ord (X.germToFunctionField U s) x := by
  simpa only [Algebra.smul_def, mul_one, ord_one, RingHom.algebraMap_toAlgebra]
    using X.ord_le_smul hx hs (1 : X.functionField)

 

theorem pullbackQCartier_effective
    {X Z : Scheme} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] [IsNoetherian Z]
    (hNormal : ∀ z : Z, IsIntegrallyClosed (Z.presheaf.stalk z))
    (f : X ⟶ Z) [IsDominant f] (D : RationalWeilDivisor Z) (hD : IsQCartier Z D)
    (heff : ∀ p : PrimeDivisor Z, 0 ≤ D p) :
    ∀ p : PrimeDivisor X, 0 ≤ pullbackQCartier hNormal f D hD p := by
  intro p
  let c := hD.data
  let U := c.chart (f p.1)
  let : Nonempty U := ⟨⟨f p.1, c.mem_chart (f p.1)⟩⟩
  let u := c.equation (f p.1)
  obtain ⟨s, hs⟩ := exists_section_of_ord_nonneg Z hNormal U
    (u : Z.functionField) (Units.ne_zero u) (by
      intro z hz hcodim
      have heq := c.ord_eq (f p.1) ⟨z, hcodim⟩ hz
      have hq : (0 : ℚ) ≤ (Z.ord (u : Z.functionField) z : ℚ) := by
        rw [← heq]
        exact mul_nonneg (Nat.cast_nonneg _) (heff _)
      exact_mod_cast hq)
  change Z.germToFunctionField U s = (u : Z.functionField) at hs
  have hnz : functionFieldPullback f (u : Z.functionField) ≠ 0 := by
    exact (map_ne_zero (functionFieldPullback f)).mpr (Units.ne_zero u)
  have hbs : f.app U s ≠ 0 := by
    intro hz
    apply hnz
    rw [← hs, functionFieldPullback_germ, hz, map_zero]
  have hnonneg := ord_nonneg_of_section X (f ⁻¹ᵁ U) (f.app U s) hbs p.1 (c.mem_chart _)
  rw [← functionFieldPullback_germ, hs] at hnonneg
  change 0 ≤ (X.ord (functionFieldPullback f (u : Z.functionField)) p.1 : ℚ) / c.index
  exact div_nonneg (by exact_mod_cast hnonneg) (Nat.cast_nonneg _)

 

theorem pullback_mem_divisorialSections
    {X Z : Scheme} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] [IsNoetherian Z]
    (hNormal : ∀ z : Z, IsIntegrallyClosed (Z.presheaf.stalk z))
    (f : X ⟶ Z) [IsDominant f] (D : RationalWeilDivisor Z) (hD : IsQCartier Z D)
    (v : Z.functionFieldˣ) (hv : v ∈ divisorialSections Z D) :
    Units.map (functionFieldPullback f).toMonoidHom v ∈
      divisorialSections X (pullbackQCartier hNormal f D hD) := by
  rw [mem_divisorialSections_iff] at hv ⊢
  have hpr := isQCartier_principal Z v
  have hsum := isQCartier_add hD hpr
  have heff := pullbackQCartier_effective hNormal f
    (D + rationalPrincipalDivisor Z v) hsum (by
      intro p
      simpa using hv p)
  rw [pullbackQCartier_add hNormal f hD hpr hsum,
    pullbackQCartier_principal hNormal f v hpr] at heff
  exact heff

 

theorem lift_section_of_exact_presentation
    {X Z : Scheme} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] [IsNoetherian Z]
    (hNZ : ∀ z : Z, IsIntegrallyClosed (Z.presheaf.stalk z))
    (f : X ⟶ Z) [IsDominant f]
    (A : RationalWeilDivisor X) (D : RationalWeilDivisor Z) (hD : IsQCartier Z D)
    (χ : X.functionFieldˣ)
    (heq : A + rationalPrincipalDivisor X χ = pullbackQCartier hNZ f D hD)
    (v : Z.functionFieldˣ) (hv : v ∈ divisorialSections Z D) :
    χ * Units.map (functionFieldPullback f).toMonoidHom v ∈ divisorialSections X A := by
  have h := pullback_mem_divisorialSections hNZ f D hD v hv
  rw [← heq, mem_divisorialSections_iff] at h
  rw [mem_divisorialSections_iff]
  intro p
  simpa only [Finsupp.add_apply, rationalPrincipalDivisor_apply,
    Units.val_mul, X.ord_mul (Units.ne_zero χ) (Units.ne_zero _), Int.cast_add, add_assoc]
    using h p

 

theorem section_quotient_descends_of_exact_presentation
    {X Z : Scheme} [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]
    (A : RationalWeilDivisor X) (D : RationalWeilDivisor Z) (hD : IsQCartier Z D)
    (χ : X.functionFieldˣ)
    (heq : A + rationalPrincipalDivisor X χ = pullbackQCartier hNZ f D hD)
    (u : X.functionFieldˣ) (hu : u ∈ divisorialSections X A) :
    ∃ v : Z.functionFieldˣ,
      functionFieldPullback f (v : Z.functionField) = ((u / χ : X.functionFieldˣ) : X.functionField) := by
  apply rational_function_descends_of_no_horizontal_poles hNX f (u / χ)
  intro p hgen
  have hzero : pullbackQCartier hNZ f D hD p = 0 := by
    by_contra hn
    exact isVertical_pullbackQCartier hNZ f D hD p hn hgen
  have hp := congrArg (fun B : RationalWeilDivisor X => B p) heq
  simp only [Finsupp.add_apply, rationalPrincipalDivisor_apply, hzero] at hp
  have hu' := (mem_divisorialSections_iff X A u).mp hu p
  have hord : (0 : ℚ) ≤ (X.ord (u : X.functionField) p.1 : ℚ) -
      (X.ord (χ : X.functionField) p.1 : ℚ) := by linarith
  simp only [Units.val_div_eq_div_val, ord_div X _ _ (Units.ne_zero u) (Units.ne_zero χ)]
  exact_mod_cast hord

 

theorem sectionField_le_base_of_exact_presentation
    {X Z : Scheme} [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]
    (A : RationalWeilDivisor X) (D : RationalWeilDivisor Z) (hD : IsQCartier Z D)
    (χ : X.functionFieldˣ)
    (heq : A + rationalPrincipalDivisor X χ = pullbackQCartier hNZ f D hD) :
    sectionField X A ≤ (functionFieldPullback f).fieldRange := by
  apply Subfield.closure_le.mpr
  rintro t ⟨u, hu, v, hv, rfl⟩
  obtain ⟨a, ha⟩ := section_quotient_descends_of_exact_presentation
    hNX hNZ f A D hD χ heq u hu
  obtain ⟨b, hb⟩ := section_quotient_descends_of_exact_presentation
    hNX hNZ f A D hD χ heq v hv
  apply RingHom.mem_fieldRange.mpr
  refine ⟨(a : Z.functionField) / (b : Z.functionField), ?_⟩
  rw [map_div₀, ha, hb]
  simp only [Units.val_div_eq_div_val]
  exact div_div_div_cancel_right₀ (Units.ne_zero χ) _ _

 

theorem base_sectionField_le_of_exact_presentation
    {X Z : Scheme} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] [IsNoetherian Z]
    (hNZ : ∀ z : Z, IsIntegrallyClosed (Z.presheaf.stalk z))
    (f : X ⟶ Z) [IsDominant f]
    (A : RationalWeilDivisor X) (D : RationalWeilDivisor Z) (hD : IsQCartier Z D)
    (χ : X.functionFieldˣ)
    (heq : A + rationalPrincipalDivisor X χ = pullbackQCartier hNZ f D hD) :
    (sectionField Z D).map (functionFieldPullback f) ≤ sectionField X A := by
  apply Subfield.map_le_iff_le_comap.mpr
  apply Subfield.closure_le.mpr
  rintro t ⟨u, hu, v, hv, rfl⟩
  change functionFieldPullback f ((u : Z.functionField) / (v : Z.functionField)) ∈ sectionField X A
  rw [map_div₀]
  apply Subfield.subset_closure
  refine ⟨χ * Units.map (functionFieldPullback f).toMonoidHom u,
    lift_section_of_exact_presentation hNZ f A D hD χ heq u hu,
    χ * Units.map (functionFieldPullback f).toMonoidHom v,
    lift_section_of_exact_presentation hNZ f A D hD χ heq v hv, ?_⟩
  simp only [Units.val_mul, Units.coe_map]
  rw [mul_div_mul_left _ _ (Units.ne_zero χ)]
  rfl

 

theorem sectionField_eq_base_of_exact_presentation
    {X Z : Scheme} [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]
    (A : RationalWeilDivisor X) (D : RationalWeilDivisor Z) (hD : IsQCartier Z D)
    (χ : X.functionFieldˣ)
    (heq : A + rationalPrincipalDivisor X χ = pullbackQCartier hNZ f D hD)
    (hne : (divisorialSections Z D).Nonempty)
    (hfield : sectionField Z D = ⊤) :
    (divisorialSections X A).Nonempty ∧
      sectionField X A = (functionFieldPullback f).fieldRange := by
  constructor
  · obtain ⟨v, hv⟩ := hne
    exact ⟨_, lift_section_of_exact_presentation hNZ f A D hD χ heq v hv⟩
  · apply le_antisymm
    · exact sectionField_le_base_of_exact_presentation hNX hNZ f A D hD χ heq
    · have h := base_sectionField_le_of_exact_presentation hNZ f A D hD χ heq
      rwa [hfield, ← RingHom.fieldRange_eq_map] at h

 

theorem positive_multiple_exact_presentation
    {X Z : Scheme} [IsIntegral X] [IsIntegral Z] [IsNoetherian X] [IsNoetherian Z]
    (hNZ : ∀ z : Z, IsIntegrallyClosed (Z.presheaf.stalk z))
    (f : X ⟶ Z) [IsDominant f]
    (A : RationalWeilDivisor X) (D : RationalWeilDivisor Z) (hD : IsQCartier Z D)
    (p : ℕ) (hp : 0 < p) (ψ : X.functionFieldˣ)
    (heq : A + (p : ℚ)⁻¹ • rationalPrincipalDivisor X ψ = pullbackQCartier hNZ f D hD)
    (l : ℕ) (hpl : p ∣ l) :
    ∃ χ : X.functionFieldˣ,
      (l : ℚ) • A + rationalPrincipalDivisor X χ =
        pullbackQCartier hNZ f ((l : ℚ) • D) (isQCartier_smul hD (l : ℚ)) := by
  obtain ⟨k, rfl⟩ := hpl
  refine ⟨ψ ^ k, ?_⟩
  rw [pullbackQCartier_smul hNZ f hD, ← heq,
    rationalPrincipalDivisor_pow, smul_add, smul_smul]
  have hpq : (p : ℚ) ≠ 0 := by exact_mod_cast hp.ne'
  have hscalar : (k : ℚ) = ((p * k : ℕ) : ℚ) * (p : ℚ)⁻¹ := by
    rw [Nat.cast_mul]
    field_simp
  rw [← hscalar]

 

theorem multiples_recover_base_of_exact_presentation_and_base_system
    {X Z : Scheme} [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]
    (A : RationalWeilDivisor X) (D : RationalWeilDivisor Z) (hD : IsQCartier Z D)
    (p : ℕ) (hp : 0 < p) (ψ : X.functionFieldˣ)
    (heq : A + (p : ℚ)⁻¹ • rationalPrincipalDivisor X ψ = pullbackQCartier hNZ f D hD)
    (s : ℕ) (hps : p ∣ s)
    (hne : (divisorialSections Z ((s : ℚ) • D)).Nonempty)
    (hfield : sectionField Z ((s : ℚ) • D) = ⊤) :
    ∀ l : ℕ, 0 < l → s ∣ l →
      (divisorialSections X ((l : ℚ) • A)).Nonempty ∧
      sectionField X ((l : ℚ) • A) = (functionFieldPullback f).fieldRange := by
  intro l hl hsl
  obtain ⟨k, hk⟩ := hsl
  have hkpos : 0 < k := by
    by_contra hn
    have hk0 : k = 0 := Nat.eq_zero_of_not_pos hn
    simp [hk, hk0] at hl
  have hequiv : (l : ℚ) • D = (k : ℚ) • ((s : ℚ) • D) := by
    rw [hk, smul_smul, Nat.cast_mul, mul_comm]
  have hne' : (divisorialSections Z ((l : ℚ) • D)).Nonempty := by
    rw [hequiv]
    exact divisorialSections_nonempty_positive_multiple Z ((s : ℚ) • D) k hne
  have hfield' : sectionField Z ((l : ℚ) • D) = ⊤ := by
    apply top_unique
    rw [← hfield]
    rw [hequiv]
    exact sectionField_le_positive_multiple Z ((s : ℚ) • D) k hkpos
  obtain ⟨χ, hχ⟩ := positive_multiple_exact_presentation hNZ f A D hD p hp ψ heq l
    (dvd_trans hps ⟨k, hk⟩)
  exact sectionField_eq_base_of_exact_presentation hNX hNZ f ((l : ℚ) • A)
    ((l : ℚ) • D) (isQCartier_smul hD (l : ℚ)) χ hχ hne' hfield'

 

def allDegreeSectionField (X : Scheme) [IsIntegral X] [IsNoetherian X]
    (A : RationalWeilDivisor X) : Subfield X.functionField :=
  ⨆ n : ℕ+, sectionField X (((n : ℕ) : ℚ) • A)

 

theorem sectionField_le_base_of_rational_presentation
    {X Z : Scheme} [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]
    (A : RationalWeilDivisor X) (D : RationalWeilDivisor Z) (hD : IsQCartier Z D)
    (p : ℕ) (hp : 0 < p) (ψ : X.functionFieldˣ)
    (heq : A + (p : ℚ)⁻¹ • rationalPrincipalDivisor X ψ = pullbackQCartier hNZ f D hD)
    (n : ℕ) :
    sectionField X ((n : ℚ) • A) ≤ (functionFieldPullback f).fieldRange := by
  apply (sectionField_le_positive_multiple X ((n : ℚ) • A) p hp).trans
  rw [smul_smul, ← Nat.cast_mul]
  obtain ⟨χ, hχ⟩ := positive_multiple_exact_presentation hNZ f A D hD p hp ψ heq
    (p * n) (dvd_mul_right p n)
  exact sectionField_le_base_of_exact_presentation hNX hNZ f _ _
    (isQCartier_smul hD ((p * n : ℕ) : ℚ)) χ hχ

 

theorem sectionField_le_base_of_rationallyLinearlyEquivalent_pullback
    {X Z : Scheme} [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]
    (A : RationalWeilDivisor X) (D : RationalWeilDivisor Z) (hD : IsQCartier Z D)
    (hlinear : RationallyLinearlyEquivalent X A (pullbackQCartier hNZ f D hD))
    (n : ℕ) :
    sectionField X ((n : ℚ) • A) ≤ (functionFieldPullback f).fieldRange := by
  obtain ⟨p, hp, ψ, hψ⟩ := hlinear
  have heq : A + (p : ℚ)⁻¹ • rationalPrincipalDivisor X ψ⁻¹ =
      pullbackQCartier hNZ f D hD := by
    rw [rationalPrincipalDivisor_inv, ← hψ, smul_neg, smul_smul,
      inv_mul_cancel₀ (Nat.cast_ne_zero.mpr hp.ne'), one_smul]
    abel
  exact sectionField_le_base_of_rational_presentation hNX hNZ f A D hD p hp ψ⁻¹ heq n

 

theorem allDegreeSectionField_le_base_of_rationallyLinearlyEquivalent_pullback
    {X Z : Scheme} [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]
    (A : RationalWeilDivisor X) (D : RationalWeilDivisor Z) (hD : IsQCartier Z D)
    (hlinear : RationallyLinearlyEquivalent X A (pullbackQCartier hNZ f D hD)) :
    allDegreeSectionField X A ≤ (functionFieldPullback f).fieldRange := by
  apply iSup_le
  intro n
  exact sectionField_le_base_of_rationallyLinearlyEquivalent_pullback hNX hNZ f A D hD
    hlinear n

 

theorem allDegreeSectionField_eq_base_of_exact_presentation_and_base_system
    {X Z : Scheme} [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]
    (A : RationalWeilDivisor X) (D : RationalWeilDivisor Z) (hD : IsQCartier Z D)
    (p : ℕ) (hp : 0 < p) (ψ : X.functionFieldˣ)
    (heq : A + (p : ℚ)⁻¹ • rationalPrincipalDivisor X ψ = pullbackQCartier hNZ f D hD)
    (s : ℕ) (hs : 0 < s) (hps : p ∣ s)
    (hne : (divisorialSections Z ((s : ℚ) • D)).Nonempty)
    (hfield : sectionField Z ((s : ℚ) • D) = ⊤) :
    allDegreeSectionField X A = (functionFieldPullback f).fieldRange := by
  apply le_antisymm
  · apply iSup_le
    intro n
    exact sectionField_le_base_of_rational_presentation hNX hNZ f A D hD p hp ψ heq n
  · have h :=
      (multiples_recover_base_of_exact_presentation_and_base_system hNX hNZ f A D hD
        p hp ψ heq s hps hne hfield s hs dvd_rfl).2
    rw [← h]
    exact le_iSup (fun n : ℕ+ => sectionField X (((n : ℕ) : ℚ) • A)) ⟨s, hs⟩

end RelativeDenominators
end

end OAI