import Mathlib
import OAI.AlgebraicGeometry.NumericalDimension.TerminalModels

namespace OAI

/-! Canonical Pullbacks. -/

open AlgebraicGeometry CategoryTheory
open scoped TensorProduct nonZeroDivisors
open scoped TensorProduct
open AlgebraicGeometry CategoryTheory TopologicalSpace
open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace

namespace NumericalDimensionOne
open AlgebraicGeometry CategoryTheory
lemma rationalTopFormPullback_birational_bijective
    {X Y : Scheme} [IsIntegral X] [IsIntegral Y]
    (sX : X ⟶ Spec (.of ℂ)) (sY : Y ⟶ Spec (.of ℂ))
    (f : X ⟶ Y) [IsDominant f] (hb : IsBirationalMorphism f)
    (hf : f ≫ sY = sX) (n : ℕ) :
    Function.Bijective (rationalTopFormPullback (.of ℂ) sX sY f hf n) := by
  let := schemeFieldAlgebra (.of ℂ) sX
  let := schemeFieldAlgebra (.of ℂ) sY
  let := (dominantFunctionFieldMap f).toAlgebra
  let : IsScalarTower ℂ Y.functionField X.functionField :=
    IsScalarTower.of_algebraMap_eq (fun a =>
      (dominantFunctionFieldMap_scalar (.of ℂ) sX sY f hf a).symm)
  apply topDifferentialMap_bijective_of_algebraMap_bijective ℂ Y.functionField X.functionField
  obtain ⟨φ,hφ⟩ := hb
  refine ⟨(dominantFunctionFieldMap f).injective, ?_⟩
  intro a
  refine ⟨partialIsoFunctionFieldEquiv φ a, ?_⟩
  apply (partialIsoFunctionFieldEquiv φ).injective
  exact partialIso_dominantFunctionFieldMap f φ hφ _
lemma exists_canonicalDivisorOf_nonzero
    (W : ComplexProjectiveVariety) (n : ℕ) (hW : IsSmoothNfold W n)
    (ω : rationalTopForms (.of ℂ) W.structureMap n) (hω : ω ≠ 0) :
    ∃ KW : WeilDivisor W.scheme, IsCanonicalDivisorOf (.of ℂ) W.structureMap n ω KW := by
  let : SmoothOfRelativeDimension n W.structureMap := hW
  obtain ⟨D,η,hD⟩ := exists_canonicalDivisor_of_smooth W.structureMap n
  let := schemeFieldAlgebra (.of ℂ) W.structureMap
  obtain ⟨b⟩ := nonempty_smooth_canonical_field_basis W.structureMap n
  let a := b.repr η 0
  let a' := b.repr ω 0
  have hη : η = a • b 0 := basis_singleton_repr b η
  have hω' : ω = a' • b 0 := basis_singleton_repr b ω
  have ha : a ≠ 0 := by
    intro ha
    exact hD.1 (by simpa [ha] using hη)
  have ha' : a' ≠ 0 := by
    intro ha'
    exact hω (by simpa [ha'] using hω')
  have heq : (a' / a) • η = ω := by
    rw [hη,← mul_smul,div_mul_cancel₀ _ ha,← hω']
  refine ⟨D + principalWeilDivisor (a' / a),?_⟩
  simpa only [heq] using canonicalDivisorOf_smul W.structureMap n hD (div_ne_zero ha' ha)
lemma exists_canonicalDivisorOf_birational_pullback {n : ℕ}
    (Y : CanonicalModel n) (W : ComplexProjectiveVariety) (hW : IsSmoothNfold W n)
    (q : W.scheme ⟶ Y.scheme) [IsDominant q] (hqb : IsBirationalMorphism q)
    (hq : q ≫ Y.structureMap = W.structureMap) :
    ∃ KW : WeilDivisor W.scheme, IsCanonicalDivisorOf (.of ℂ) W.structureMap n
      (rationalTopFormPullback (.of ℂ) W.structureMap Y.structureMap q hq n Y.form) KW := by
  apply exists_canonicalDivisorOf_nonzero W n hW
  intro hz
  apply Y.canonical_of_form.1
  have hi := (rationalTopFormPullback_birational_bijective W.structureMap Y.structureMap
    q hqb hq n).1
  apply hi
  exact hz.trans (by simp only [rationalTopFormPullback,map_zero])
end NumericalDimensionOne

open AlgebraicGeometry CategoryTheory
open scoped TensorProduct nonZeroDivisors
open scoped TensorProduct
open AlgebraicGeometry CategoryTheory TopologicalSpace
open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace

namespace NumericalDimensionOne
open AlgebraicGeometry CategoryTheory
lemma CompatibleCanonicalData.iff_morphism {n : ℕ} {X Y : CanonicalModel n}
    (f : X.scheme ⟶ Y.scheme) [hfDom : IsDominant f]
    (hf : f ≫ Y.structureMap = X.structureMap)
    (φ : X.scheme.PartialIso Y.scheme) (hφ : φ.IsOver f (𝟙 Y.scheme))
    (hbase : φ.IsOver X.structureMap Y.structureMap) :
    CompatibleCanonicalData X Y φ hbase ↔ X.form =
      rationalTopFormPullback (.of ℂ) X.structureMap Y.structureMap f hf n Y.form := by
  have hb : IsBirationalMorphism φ.source.ι :=
    φ.source.ι.birationalOver (𝟙 X.scheme) φ.source.ι (Category.comp_id _)
  have hi := (rationalTopFormPullback_birational_bijective
    (φ.source.ι ≫ X.structureMap) X.structureMap φ.source.ι hb rfl n).1
  have he : φ.source.ι ≫ f = φ.iso.hom ≫ φ.target.ι := by
    simpa only [Scheme.PartialIso.IsOver,Category.comp_id] using (show φ.iso.hom ≫ φ.target.ι ≫ (𝟙 Y.scheme) = φ.source.ι ≫ f from hφ).symm
  have hcomp : (φ.source.ι ≫ f) ≫ Y.structureMap = φ.source.ι ≫ X.structureMap := by
    rw [Category.assoc,hf]
  have hiso : (φ.iso.hom ≫ φ.target.ι) ≫ Y.structureMap = φ.source.ι ≫ X.structureMap := by
    simpa only [Category.assoc] using hbase
  have heq := congrFun (rationalTopFormPullback_congr (.of ℂ)
    (φ.source.ι ≫ X.structureMap) Y.structureMap (φ.source.ι ≫ f)
    (φ.iso.hom ≫ φ.target.ι) hcomp hiso he n) Y.form
  have hw := rationalTopFormPullback_comp (.of ℂ)
    (φ.source.ι ≫ X.structureMap) X.structureMap Y.structureMap
    φ.source.ι f rfl hf n Y.form
  change rationalTopFormPullback _ _ _ φ.source.ι rfl n X.form =
    rationalTopFormPullback _ _ _ (φ.iso.hom ≫ φ.target.ι) hiso n Y.form ↔ _
  rw [← heq,hw]
  exact hi.eq_iff
noncomputable def canonicalModelOfForm (W : ComplexProjectiveVariety) (n : ℕ)
    (hW : IsSmoothNfold W n) (ω : rationalTopForms (.of ℂ) W.structureMap n)
    (KW : WeilDivisor W.scheme)
    (hKW : IsCanonicalDivisorOf (.of ℂ) W.structureMap n ω KW) : CanonicalModel n := by
  let : SmoothOfRelativeDimension n W.structureMap := hW
  have hCartier : IsCartierDivisor KW :=
    isCartier_of_isCanonical W.structureMap n ⟨_,hKW⟩
  exact {
    toNormalProjectiveVariety := { toComplexProjectiveVariety := W, normal := smoothNormal W hW }
    form := ω
    canonical := KW
    canonical_of_form := hKW
    qCartier := ⟨1,by decide,KW,hCartier,by simp⟩ }
lemma exists_common_canonicalDivisor {n : ℕ}
    (X Y : CanonicalModel n) (φ : X.scheme.PartialIso Y.scheme)
    (hbase : φ.IsOver X.structureMap Y.structureMap)
    (hc : CompatibleCanonicalData X Y φ hbase)
    (W : ComplexProjectiveVariety) (hW : IsSmoothNfold W n)
    (p : W.scheme ⟶ X.scheme) (q : W.scheme ⟶ Y.scheme)
    [IsDominant p] [IsDominant q]
    (hp : p ≫ X.structureMap = W.structureMap) (hq : q ≫ Y.structureMap = W.structureMap)
    (θ : W.scheme.PartialIso X.scheme) (hθp : θ.IsOver p (𝟙 X.scheme))
    (hθq : (θ.trans φ).IsOver q (𝟙 Y.scheme)) :
    ∃ KW : WeilDivisor W.scheme,
      IsCanonicalDivisorOf (.of ℂ) W.structureMap n
        (rationalTopFormPullback (.of ℂ) W.structureMap X.structureMap p hp n X.form) KW ∧
      IsCanonicalDivisorOf (.of ℂ) W.structureMap n
        (rationalTopFormPullback (.of ℂ) W.structureMap Y.structureMap q hq n Y.form) KW := by
  obtain ⟨KW,hKW⟩ := exists_canonicalDivisorOf_birational_pullback X W hW p ⟨θ,hθp⟩ hp
  let Z := canonicalModelOfForm W n hW _ KW hKW
  have hθbase : θ.IsOver Z.structureMap X.structureMap := by
    change θ.iso.hom ≫ θ.target.ι ≫ X.structureMap = θ.source.ι ≫ W.structureMap
    rw [← hp,← Category.assoc,← Category.assoc]
    exact congrArg (fun r => r ≫ X.structureMap)
      (show θ.iso.hom ≫ θ.target.ι = θ.source.ι ≫ p from by
        simpa only [Scheme.PartialIso.IsOver,Category.comp_id] using hθp)
  have hZX : CompatibleCanonicalData Z X θ hθbase :=
    (CompatibleCanonicalData.iff_morphism (X := Z) (Y := X) p (hfDom := inferInstanceAs (IsDominant p)) hp θ hθp hθbase).mpr rfl
  have hZY := hZX.trans hc
  have hform := (CompatibleCanonicalData.iff_morphism (X := Z) (Y := Y) q (hfDom := inferInstanceAs (IsDominant q)) hq (θ.trans φ) hθq
    (hθbase.trans hbase)).mp hZY
  refine ⟨KW,hKW,?_⟩
  change rationalTopFormPullback (.of ℂ) W.structureMap X.structureMap p hp n X.form =
    rationalTopFormPullback (.of ℂ) W.structureMap Y.structureMap q hq n Y.form at hform
  rw [← hform]
  exact hKW
end NumericalDimensionOne

open AlgebraicGeometry CategoryTheory
open scoped TensorProduct nonZeroDivisors
open scoped TensorProduct
open AlgebraicGeometry CategoryTheory TopologicalSpace
open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace

namespace NumericalDimensionOne
open AlgebraicGeometry CategoryTheory
lemma exists_qCartierPullback
    {X Y : Scheme} [IsIntegral X] [IsIntegral Y]
    [IsLocallyNoetherian X] [IsLocallyNoetherian Y] [StalkwiseNormal Y] [CompactSpace X]
    (f : X ⟶ Y) [IsDominant f] (D : QWeilDivisor Y) (hD : IsQCartierDivisor D) :
    ∃ E : QWeilDivisor X, IsQCartierPullback f D E := by
  obtain ⟨m,hm,A,hA,hAD⟩ := hD
  obtain ⟨B,hB⟩ := exists_cartierPullback f A hA
  let E : QWeilDivisor X := (m : ℚ)⁻¹ • rationalWeilDivisor B
  refine ⟨E,m,hm,A,B,hA,hAD,?_,hB⟩
  ext p
  change (m : ℚ) * ((m : ℚ)⁻¹ * (B p : ℚ)) = (B p : ℚ)
  rw [← mul_assoc,mul_inv_cancel₀ (show (m : ℚ) ≠ 0 by exact_mod_cast hm.ne'),one_mul]
end NumericalDimensionOne

open AlgebraicGeometry CategoryTheory
open scoped TensorProduct nonZeroDivisors
open scoped TensorProduct
open AlgebraicGeometry CategoryTheory TopologicalSpace
open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace

namespace NumericalDimensionOne
open AlgebraicGeometry CategoryTheory TopologicalSpace
lemma restricted_partialIso_map {X Y : Scheme} (φ : X.PartialIso Y)
    (V : X.Opens) (hV : Dense (V : Set X)) (hle : V ≤ φ.source) :
    (φ.restrictSource V hV hle).iso.hom ≫ (φ.restrictSource V hV hle).target.ι =
      X.homOfLE hle ≫ φ.iso.hom ≫ φ.target.ι := by
  have h : (Scheme.Opens.isoOfLE hle).inv ≫ (φ.source.ι ⁻¹ᵁ V).ι = X.homOfLE hle := by
    apply (cancel_mono φ.source.ι).mp
    simp only [Category.assoc, Scheme.Opens.isoOfLE_inv_ι, Scheme.homOfLE_ι]
  simp [Scheme.PartialIso.restrictSource]
  rw [← Category.assoc,h]
lemma common_model_on_partial_locus
    {W X Y : Scheme} [IsIntegral W] [X.IsSeparated]
    (p : W ⟶ X) (q : W ⟶ Y)
    (φ : X.PartialIso Y) (θ : W.PartialIso X)
    (hθp : θ.IsOver p (𝟙 X)) (hθq : (θ.trans φ).IsOver q (𝟙 Y))
    (w : W) (hw : q w ∈ φ.target) :
    p w = φ.source.ι (φ.iso.inv ⟨q w,hw⟩) := by
  let V := θ.target ⊓ φ.source
  have hV : Dense (V : Set X) := θ.dense_target.inter_of_isOpen_right φ.dense_source φ.source.isOpen
  let α := θ.restrictTarget V hV inf_le_left
  let β := φ.restrictSource V hV inf_le_right
  let a : α.source.toScheme ⟶ φ.source.toScheme := α.iso.hom ≫ X.homOfLE inf_le_right
  have hp' : a ≫ φ.source.ι = α.source.ι ≫ p := by
    dsimp only [a]
    erw [Category.assoc,Scheme.homOfLE_ι]
    simpa only [Scheme.PartialIso.IsOver,Category.comp_id] using
      (hθp.restrictTarget V hV inf_le_left)
  have hq' : a ≫ φ.iso.hom ≫ φ.target.ι = α.source.ι ≫ q := by
    have hβ := restricted_partialIso_map φ V hV inf_le_right
    have hi : (X.isoOfEq (show α.target = β.source from rfl)).hom = 𝟙 V.toScheme :=
      congrArg Iso.hom (X.isoOfEq_rfl V)
    have hh : α.iso.hom ≫ β.iso.hom ≫ β.target.ι = α.source.ι ≫ q := by
      change α.iso.hom ≫ (X.isoOfEq (show α.target = β.source from rfl)).hom ≫
        β.iso.hom ≫ β.target.ι ≫ (𝟙 Y) = α.source.ι ≫ q at hθq
      erw [hi,Category.id_comp,Category.comp_id] at hθq
      exact hθq
    dsimp only [β] at hh
    erw [hβ] at hh
    exact hh
  let U := q ⁻¹ᵁ φ.target
  let qU : U.toScheme ⟶ φ.target.toScheme :=
    IsOpenImmersion.lift φ.target.ι (U.ι ≫ q) (by
      rintro _ ⟨x,rfl⟩
      exact ⟨⟨q x.1,x.2⟩,rfl⟩)
  have hsub : α.source ≤ U := by
    intro z hz
    have hh := congrArg (fun f : α.source.toScheme ⟶ Y => f ⟨z,hz⟩) hq'
    change q z ∈ φ.target
    change φ.target.ι (φ.iso.hom (a ⟨z,hz⟩)) = q z at hh
    rw [← hh]
    exact (φ.iso.hom (a ⟨z,hz⟩)).2
  let j := W.homOfLE hsub
  let : IsDominant j := Opens.isDominant_homOfLE α.dense_source hsub
  have hqU : qU ≫ φ.target.ι = U.ι ≫ q := IsOpenImmersion.lift_fac _ _ _
  have he : U.ι ≫ p = qU ≫ φ.iso.inv ≫ φ.source.ι := by
    apply ext_of_isDominant j
    have hj : j ≫ qU = a ≫ φ.iso.hom := by
      apply (cancel_mono φ.target.ι).mp
      rw [Category.assoc,hqU,← Category.assoc,
        show j ≫ U.ι = α.source.ι from W.homOfLE_ι hsub]
      exact hq'.symm
    rw [← Category.assoc,show j ≫ U.ι = α.source.ι from W.homOfLE_ι hsub,
      ← hp',← Category.assoc,← Category.assoc,hj]
    simp only [Category.assoc,Iso.hom_inv_id_assoc]
  have hh := congrArg (fun f : U.toScheme ⟶ X => f ⟨w,hw⟩) he
  have hqu : qU ⟨w,hw⟩ = ⟨q w,hw⟩ := by
    apply Subtype.ext
    exact congrArg (fun f : U.toScheme ⟶ Y => f ⟨w,hw⟩)
      (IsOpenImmersion.lift_fac φ.target.ι (U.ι ≫ q) _)
  change p w = φ.source.ι (φ.iso.inv (qU ⟨w,hw⟩)) at hh
  exact hh.trans (congrArg (fun z => φ.source.ι (φ.iso.inv z)) hqu)
lemma common_model_prime_noExtraction
    {W X Y : Scheme} [IsIntegral W] [X.IsSeparated]
    (p : W ⟶ X) (q : W ⟶ Y)
    (φ : X.PartialIso Y) (θ : W.PartialIso X)
    (hθp : θ.IsOver p (𝟙 X)) (hθq : (θ.trans φ).IsOver q (𝟙 Y))
    (hφ : NoExtractionOn φ) (F : PrimeDivisor W)
    (hF : Order.coheight (q F.1) = 1) :
    Order.coheight (p F.1) = 1 := by
  have hm := hφ ⟨q F.1,hF⟩
  let z : φ.target.toScheme := ⟨q F.1,hm⟩
  calc
    _ = Order.coheight (φ.source.ι (φ.iso.inv z)) :=
      congrArg Order.coheight (common_model_on_partial_locus p q φ θ hθp hθq F.1 hm)
    _ = Order.coheight (φ.iso.inv z) := coheight_eq_of_isOpenImmersion φ.source.ι
    _ = Order.coheight z := coheight_eq_of_isOpenImmersion φ.iso.inv
    _ = Order.coheight (q F.1) := (coheight_eq_of_isOpenImmersion (x := z) φ.target.ι).symm
    _ = 1 := hF
end NumericalDimensionOne

open AlgebraicGeometry CategoryTheory
open scoped TensorProduct nonZeroDivisors
open scoped TensorProduct
open AlgebraicGeometry CategoryTheory TopologicalSpace
open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace

namespace NumericalDimensionOne
open AlgebraicGeometry CategoryTheory TopologicalSpace
lemma canonical_comparison_support_and_strictness {n : ℕ}
    (X Y : CanonicalModel n) (hX : IsSmoothNfold X.toComplexProjectiveVariety n)
    (hY : IsTerminalModel Y) (φ : X.scheme.PartialIso Y.scheme)
    (hφ : NoExtractionOn φ) (hbase : φ.IsOver X.structureMap Y.structureMap)
    (hc : CompatibleCanonicalData X Y φ hbase)
    (W : ComplexProjectiveVariety) (hW : IsSmoothNfold W n)
    (p : W.scheme ⟶ X.scheme) (q : W.scheme ⟶ Y.scheme)
    [IsDominant p] [IsDominant q] [IsProper p] [IsProper q]
    (hp : p ≫ X.structureMap = W.structureMap) (hq : q ≫ Y.structureMap = W.structureMap)
    (θ : W.scheme.PartialIso X.scheme) (hθp : θ.IsOver p (𝟙 X.scheme))
    (hθq : (θ.trans φ).IsOver q (𝟙 Y.scheme)) :
    ∃ P Q : QWeilDivisor W.scheme,
      IsQCartierPullback p (rationalWeilDivisor X.canonical) P ∧
      IsQCartierPullback q (rationalWeilDivisor Y.canonical) Q ∧
      (∀ F : PrimeDivisor W.scheme, (P-Q) F ≠ 0 → 1 < Order.coheight (q F.1)) ∧
      (∀ F : PrimeDivisor W.scheme, Order.coheight (p F.1) = 1 →
        1 < Order.coheight (q F.1) → 0 < (P-Q) F) := by
  let : X.scheme.IsSeparated := ⟨by
    have h : IsSeparated (X.structureMap ≫ CategoryTheory.Limits.terminal.from _) := inferInstance
    simpa only [CategoryTheory.Limits.terminal.comp_from] using h⟩
  have hpb : IsBirationalMorphism p := ⟨θ,hθp⟩
  have hqb : IsBirationalMorphism q := ⟨θ.trans φ,hθq⟩
  obtain ⟨KW,hKp,hKq⟩ := exists_common_canonicalDivisor X Y φ hbase hc W hW p q hp hq θ hθp hθq
  obtain ⟨P,hP⟩ := exists_qCartierPullback p _ X.qCartier
  obtain ⟨Q,hQ⟩ := exists_qCartierPullback q _ Y.qCartier
  refine ⟨P,Q,hP,hQ,?_,?_⟩
  · intro F hF
    have hz : Order.coheight (q F.1) ≠ 0 := by
      intro he
      have hsp : q F.1 ⤳ genericPoint Y.scheme :=
        (Order.coheight_eq_zero.mp he) (genericPoint_specializes (q F.1))
      have heq := (hsp.antisymm (genericPoint_specializes (q F.1))).eq
      have hFη := birational_generic_fiber q hqb F.1 heq
      have h0 : Order.coheight F.1 = 0 := by
        rw [hFη]
        exact Order.coheight_eq_zero.mpr (fun x _ => genericPoint_specializes x)
      rw [F.2] at h0
      exact one_ne_zero h0
    apply lt_of_le_of_ne (Order.one_le_iff_ne_zero.mpr hz)
    intro he
    have hprime := common_model_prime_noExtraction p q φ θ hθp hθq hφ F he.symm
    have hP0 := relativeCanonical_vanishes_over_prime X W hW p hpb hp KW hKp P hP F hprime
    have hQ0 := relativeCanonical_vanishes_over_prime Y W hW q hqb hq KW hKq Q hQ F he.symm
    change (KW F : ℚ) - P F = 0 at hP0
    change (KW F : ℚ) - Q F = 0 at hQ0
    apply hF
    change P F - Q F = 0
    exact sub_eq_zero.mpr ((sub_eq_zero.mp hP0).symm.trans (sub_eq_zero.mp hQ0))
  · intro F hFp hFq
    exact canonical_comparison_strict_source_primes X Y hX hY W hW p q hpb hqb hp hq
      KW hKp hKq P Q hP hQ F hFp hFq
end NumericalDimensionOne

open AlgebraicGeometry CategoryTheory
open scoped TensorProduct nonZeroDivisors
open scoped TensorProduct
open AlgebraicGeometry CategoryTheory TopologicalSpace
open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace

namespace NumericalDimensionOne
open AlgebraicGeometry CategoryTheory
lemma HasEffectiveCanonicalComparison.of_birational_morphism {n : ℕ}
    (X Y : CanonicalModel n) (hX : IsSmoothNfold X.toComplexProjectiveVariety n)
    (hY : IsTerminalModel Y) (φ : X.scheme.PartialIso Y.scheme)
    (hbase : φ.IsOver X.structureMap Y.structureMap)
    (hc : CompatibleCanonicalData X Y φ hbase)
    (f : X.scheme ⟶ Y.scheme) [IsDominant f] [IsProper f]
    (hf : f ≫ Y.structureMap = X.structureMap) (hreal : φ.IsOver f (𝟙 Y.scheme)) :
    HasEffectiveCanonicalComparison X Y φ := by
  have hfb : IsBirationalMorphism f := ⟨φ,hreal⟩
  have hform := (CompatibleCanonicalData.iff_morphism f hf φ hreal hbase).mp hc
  have hK : IsCanonicalDivisorOf (.of ℂ) X.structureMap n
      (rationalTopFormPullback (.of ℂ) X.structureMap Y.structureMap f hf n Y.form) X.canonical := by
    rw [← hform]
    exact X.canonical_of_form
  obtain ⟨Q,hQ⟩ := exists_qCartierPullback f _ Y.qCartier
  obtain ⟨hE,hsupp⟩ := relativeCanonical_effective_terminal Y hY X.toComplexProjectiveVariety hX
    f hfb hf X.canonical hK Q hQ
  have hi : (Scheme.PartialIso.refl X.scheme).IsOver (𝟙 X.scheme) (𝟙 X.scheme) :=
    Category.id_comp _
  have hi' : (Scheme.PartialIso.refl X.scheme).IsOver f f := Category.id_comp _
  refine ⟨X.toComplexProjectiveVariety,hX,𝟙 X.scheme,f,
    inferInstance,inferInstance,inferInstance,inferInstance,Category.id_comp _,hf,
    .refl X.scheme,hi,hi'.trans hreal,rationalWeilDivisor X.canonical,Q,
    rationalWeilDivisor X.canonical-Q,X.qCartier.pullback_id,hQ,?_,hE,?_,?_⟩
  · exact (add_sub_cancel _ _).symm
  · intro F hF
    exact (hsupp F).mp hF
  · intro F _ hF
    exact hY X.toComplexProjectiveVariety hX f inferInstance inferInstance hfb hf
      X.canonical hK Q hQ F hF
end NumericalDimensionOne

open AlgebraicGeometry CategoryTheory
open scoped TensorProduct nonZeroDivisors
open scoped TensorProduct
open AlgebraicGeometry CategoryTheory TopologicalSpace
open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace

namespace NumericalDimensionOne
open AlgebraicGeometry CategoryTheory
section
variable {X Y : Scheme} [IsIntegral X] [IsIntegral Y]
    [IsLocallyNoetherian X] [IsLocallyNoetherian Y]
lemma IsQCartierPullback.add {f : X ⟶ Y} [IsDominant f]
    {D E : QWeilDivisor Y} {P Q : QWeilDivisor X}
    (hP : IsQCartierPullback f D P) (hQ : IsQCartierPullback f E Q) :
    IsQCartierPullback f (D+E) (P+Q) := by
  obtain ⟨m,hm,A,B,hA,hAD,hBP,hAB⟩ := hP
  obtain ⟨n,hn,C,G,hC,hCE,hGQ,hCG⟩ := hQ
  refine ⟨m*n,Nat.mul_pos hm hn,n • A + m • C,n • B + m • G,
    isCartierDivisor_add ((cartierDivisors (X := Y)).nsmul_mem hA n)
      ((cartierDivisors (X := Y)).nsmul_mem hC m),?_,?_,(hAB.nsmul n).add (hCG.nsmul m)⟩
  · ext p
    have hd := DFunLike.congr_fun hAD p
    have he := DFunLike.congr_fun hCE p
    change (m : ℚ) * D p = (A p : ℚ) at hd
    change (n : ℚ) * E p = (C p : ℚ) at he
    change ((m*n : ℕ) : ℚ) * (D p + E p) = ((n : ℤ) * A p + (m : ℤ) * C p : ℤ)
    push_cast
    rw [← hd,← he]
    ring
  · ext p
    have hp := DFunLike.congr_fun hBP p
    have hq := DFunLike.congr_fun hGQ p
    change (m : ℚ) * P p = (B p : ℚ) at hp
    change (n : ℚ) * Q p = (G p : ℚ) at hq
    change ((m*n : ℕ) : ℚ) * (P p + Q p) = ((n : ℤ) * B p + (m : ℤ) * G p : ℤ)
    push_cast
    rw [← hp,← hq]
    ring
lemma IsQCartierPullback.neg {f : X ⟶ Y} [IsDominant f]
    {D : QWeilDivisor Y} {P : QWeilDivisor X} (hP : IsQCartierPullback f D P) :
    IsQCartierPullback f (-D) (-P) := by
  obtain ⟨m,hm,A,B,hA,hAD,hBP,hAB⟩ := hP
  refine ⟨m,hm,-A,-B,isCartierDivisor_neg hA,?_,?_,hAB.neg⟩
  · ext p
    have h := DFunLike.congr_fun hAD p
    change (m : ℚ) * D p = (A p : ℚ) at h
    change (m : ℚ) * (-D p) = ((-A p : ℤ) : ℚ)
    simp only [Int.cast_neg,mul_neg,h]
  · ext p
    have h := DFunLike.congr_fun hBP p
    change (m : ℚ) * P p = (B p : ℚ) at h
    change (m : ℚ) * (-P p) = ((-B p : ℤ) : ℚ)
    simp only [Int.cast_neg,mul_neg,h]
lemma IsQCartierPullback.sub {f : X ⟶ Y} [IsDominant f]
    {D E : QWeilDivisor Y} {P Q : QWeilDivisor X}
    (hP : IsQCartierPullback f D P) (hQ : IsQCartierPullback f E Q) :
    IsQCartierPullback f (D-E) (P-Q) := by
  simpa only [sub_eq_add_neg] using hP.add hQ.neg
lemma IsQCartierPullback.mono [StalkwiseNormal X] [StalkwiseNormal Y]
    {f : X ⟶ Y} [IsDominant f]
    {D E : QWeilDivisor Y} {P Q : QWeilDivisor X}
    (hP : IsQCartierPullback f D P) (hQ : IsQCartierPullback f E Q) (hDE : D ≤ E) :
    P ≤ Q := by
  exact sub_nonneg.mp ((hQ.sub hP).nonneg (sub_nonneg.mpr hDE))
end
end NumericalDimensionOne

open AlgebraicGeometry CategoryTheory
open scoped TensorProduct nonZeroDivisors
open scoped TensorProduct
open AlgebraicGeometry CategoryTheory TopologicalSpace
open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace

namespace NumericalDimensionOne

lemma rationalWeilDivisor_injective {X : Scheme} :
    Function.Injective (@rationalWeilDivisor X) := by
  intro D E h
  ext p
  have he : (D p : ℚ) = (E p : ℚ) := DFunLike.congr_fun h p
  exact_mod_cast he

lemma rationalWeilDivisor_nsmul {X : Scheme} (D : WeilDivisor X) (m : ℕ) :
    rationalWeilDivisor (m • D) = (m : ℚ) • rationalWeilDivisor D := by
  ext p
  change ((m • D p : ℤ) : ℚ) = (m : ℚ) * (D p : ℚ)
  simp only [nsmul_eq_mul, Int.cast_mul, Int.cast_natCast]

lemma multiples_cross_equal {X : Scheme} {D : QWeilDivisor X}
    {m n : ℕ} {A B : WeilDivisor X}
    (hA : (m : ℚ) • D = rationalWeilDivisor A)
    (hB : (n : ℚ) • D = rationalWeilDivisor B) : n • A = m • B := by
  apply rationalWeilDivisor_injective
  rw [rationalWeilDivisor_nsmul, rationalWeilDivisor_nsmul, ← hA, ← hB,
    smul_smul, smul_smul, mul_comm]

lemma cartierCurveDegree_nsmul {X : ComplexProjectiveVariety} [StalkwiseNormal X.scheme]
    (D : cartierDivisors (X := X.scheme)) (C : CurveOn X) (m : ℕ) :
    cartierCurveDegree (m • D) C = m • cartierCurveDegree D C :=
  (cartierCurveDegreeHom C).map_nsmul m D

lemma isNefCartier_of_positive_multiple {X : ComplexProjectiveVariety}
    [StalkwiseNormal X.scheme] (D : cartierDivisors (X := X.scheme))
    {m : ℕ} (hm : 0 < m) (hD : IsNefCartier X (m • D)) : IsNefCartier X D := by
  intro C
  have h := hD C
  rw [cartierCurveDegree_nsmul, nsmul_eq_mul] at h
  exact nonneg_of_mul_nonneg_right h (by exact_mod_cast hm)

theorem isNefQDivisor_iff_one_multiple
    {X : ComplexProjectiveVariety} [StalkwiseNormal X.scheme]
    {D : QWeilDivisor X.scheme} (m : ℕ) (hm : 0 < m)
    (A : cartierDivisors (X := X.scheme))
    (hA : (m : ℚ) • D = rationalWeilDivisor A.1) :
    IsNefQDivisor X D ↔ IsNefCartier X A := by
  constructor
  · intro h
    exact h.2 m hm A.1 A.2 hA
  · intro h
    refine ⟨⟨m, hm, A.1, A.2, hA⟩, ?_⟩
    intro n _hn B hB heB C
    have he : n • A = m • (⟨B, hB⟩ : cartierDivisors) :=
      Subtype.ext (multiples_cross_equal hA heB)
    have hdeg := congrArg (fun T => cartierCurveDegree T C) he
    simp only [cartierCurveDegree_nsmul, nsmul_eq_mul] at hdeg
    have hnon : 0 ≤ (n : ℤ) * cartierCurveDegree A C := mul_nonneg (by positivity) (h C)
    rw [hdeg] at hnon
    exact nonneg_of_mul_nonneg_right hnon (by exact_mod_cast hm)

lemma isNefCartier_of_generated {X : ComplexProjectiveVariety}
    [StalkwiseNormal X.scheme] (D : cartierDivisors (X := X.scheme))
    (hD : ∀ x : X.scheme, IsGeneratedAt D.1 x) : IsNefCartier X D := by
  intro C
  exact cartierCurveDegree_nonneg_of_generatedAt D C (hD _)

lemma isNefCartier_of_isAmple {X : ComplexProjectiveVariety}
    [StalkwiseNormal X.scheme] (D : cartierDivisors (X := X.scheme))
    (hD : IsAmpleDivisor D.1) : IsNefCartier X D := by
  intro C
  obtain ⟨m, hm, s, hs, hsec, _, hnon, _⟩ :=
    hD.2 (C.morphism (genericPoint C.curve.scheme)) ⊤ trivial
  have hgen : IsGeneratedAt (m • D).1 (C.morphism (genericPoint C.curve.scheme)) :=
    ⟨s, hs, hsec, hnon⟩
  have h := cartierCurveDegree_nonneg_of_generatedAt (m • D) C hgen
  rw [cartierCurveDegree_nsmul, nsmul_eq_mul] at h
  exact nonneg_of_mul_nonneg_right h (by exact_mod_cast hm)

theorem isNefQDivisor_of_isAmple
    {X : ComplexProjectiveVariety} [StalkwiseNormal X.scheme]
    {D : QWeilDivisor X.scheme} (hD : IsAmpleQDivisor D) :
    IsNefQDivisor X D := by
  obtain ⟨m, hm, A, hA, heA⟩ := hD
  exact (isNefQDivisor_iff_one_multiple m hm ⟨A, hA.1⟩ heA).mpr
    (isNefCartier_of_isAmple ⟨A, hA.1⟩ hA)

end NumericalDimensionOne

open AlgebraicGeometry CategoryTheory
open scoped TensorProduct nonZeroDivisors
open scoped TensorProduct
open AlgebraicGeometry CategoryTheory TopologicalSpace
open CategoryTheory Opposite AlgebraicGeometry TopologicalSpace

namespace NumericalDimensionOne

structure CartierMultiple {X : Scheme} [IsIntegral X] [IsLocallyNoetherian X]
    (D : QWeilDivisor X) where
  denominator : ℕ
  positive : 0 < denominator
  divisor : cartierDivisors (X := X)
  equation : (denominator : ℚ) • D = rationalWeilDivisor divisor.1

noncomputable def chooseCartierMultiple {X : Scheme} [IsIntegral X]
    [IsLocallyNoetherian X] {D : QWeilDivisor X} (hD : IsQCartierDivisor D) :
    CartierMultiple D := by
  choose m hm A hA he using hD
  exact ⟨m, hm, ⟨A, hA⟩, he⟩

noncomputable def CartierMultiple.degreeOn {X : ComplexProjectiveVariety}
    [StalkwiseNormal X.scheme] {D : QWeilDivisor X.scheme}
    (M : CartierMultiple D) (C : CurveOn X) : ℚ :=
  (cartierCurveDegree M.divisor C : ℚ) / M.denominator

noncomputable def qCartierCurveDegree {X : ComplexProjectiveVariety}
    [StalkwiseNormal X.scheme] (D : QWeilDivisor X.scheme)
    (hD : IsQCartierDivisor D) (C : CurveOn X) : ℚ :=
  (chooseCartierMultiple hD).degreeOn C

end NumericalDimensionOne

end OAI